lfx-nightly 0.1.12.dev38__py3-none-any.whl → 0.1.12.dev40__py3-none-any.whl

lfx/components/logic/llm_conditional_router.py

@@ -1,8 +1,9 @@
 from typing import Any
 
-from langflow.custom import Component
-from langflow.io import BoolInput, HandleInput, MessageInput, MessageTextInput, MultilineInput, Output, TableInput
-from langflow.schema.message import Message
+from lfx.custom import Component
+from lfx.io import BoolInput, HandleInput, MessageInput, MessageTextInput, MultilineInput, Output, TableInput
+from lfx.schema.message import Message
+from lfx.schema.table import EditMode
 
 
 class SmartRouterComponent(Component):
@@ -39,21 +40,42 @@ class SmartRouterComponent(Component):
             table_schema=[
                 {
                     "name": "route_category",
-                    "display_name": "Route/Category",
+                    "display_name": "Route Name",
                     "type": "str",
-                    "description": "Name for the route/category (used for both output name and category matching)",
+                    "description": "Name for the route (used for both output name and category matching)",
+                    "edit_mode": EditMode.INLINE,
+                },
+                {
+                    "name": "route_description",
+                    "display_name": "Route Description",
+                    "type": "str",
+                    "description": "Description of when this route should be used (helps LLM understand the category)",
+                    "default": "",
+                    "edit_mode": EditMode.POPOVER,
                 },
                 {
                     "name": "output_value",
-                    "display_name": "Output Value",
+                    "display_name": "Route Message (Optional)",
                     "type": "str",
-                    "description": "Custom message for this category (overrides default output message if filled)",
+                    "description": (
+                        "Optional message to send when this route is matched."
+                        "Leave empty to pass through the original input text."
+                    ),
                     "default": "",
+                    "edit_mode": EditMode.POPOVER,
                 },
             ],
             value=[
-                {"route_category": "Positive", "output_value": ""},
-                {"route_category": "Negative", "output_value": ""},
+                {
+                    "route_category": "Positive",
+                    "route_description": "Positive feedback, satisfaction, or compliments",
+                    "output_value": "",
+                },
+                {
+                    "route_category": "Negative",
+                    "route_description": "Complaints, issues, or dissatisfaction",
+                    "output_value": "",
+                },
             ],
             real_time_refresh=True,
             required=True,
@@ -125,6 +147,7 @@ class SmartRouterComponent(Component):
         # Clear any previous match state
         self._matched_category = None
 
+        # Get categories and input text
         categories = getattr(self, "routes", [])
         input_text = getattr(self, "input_text", "")
 
@@ -134,17 +157,23 @@ class SmartRouterComponent(Component):
 
         if llm and categories:
             # Create prompt for categorization
-            category_values = [
-                category.get("route_category", f"Category {i + 1}") for i, category in enumerate(categories)
-            ]
-            categories_text = ", ".join([f'"{cat}"' for cat in category_values if cat])
+            category_info = []
+            for i, category in enumerate(categories):
+                cat_name = category.get("route_category", f"Category {i + 1}")
+                cat_desc = category.get("route_description", "")
+                if cat_desc and cat_desc.strip():
+                    category_info.append(f'"{cat_name}": {cat_desc}')
+                else:
+                    category_info.append(f'"{cat_name}"')
+
+            categories_text = "\n".join([f"- {info}" for info in category_info if info])
 
             # Create base prompt
             base_prompt = (
                 f"You are a text classifier. Given the following text and categories, "
                 f"determine which category best matches the text.\n\n"
                 f'Text to classify: "{input_text}"\n\n'
-                f"Available categories: {categories_text}\n\n"
+                f"Available categories:\n{categories_text}\n\n"
                 f"Respond with ONLY the exact category name that best matches the text. "
                 f'If none match well, respond with "NONE".\n\n'
                 f"Category:"
@@ -155,7 +184,11 @@ class SmartRouterComponent(Component):
             if custom_prompt and custom_prompt.strip():
                 self.status = "Using custom prompt as additional instructions"
                 # Format custom prompt with variables
-                formatted_custom = custom_prompt.format(input_text=input_text, routes=categories_text)
+                # For the routes variable, create a simpler format for custom prompt usage
+                simple_routes = ", ".join(
+                    [f'"{cat.get("route_category", f"Category {i + 1}")}"' for i, cat in enumerate(categories)]
+                )
+                formatted_custom = custom_prompt.format(input_text=input_text, routes=simple_routes)
                 # Combine base prompt with custom instructions
                 prompt = f"{base_prompt}\n\nAdditional Instructions:\n{formatted_custom}"
             else:
@@ -188,6 +221,7 @@ class SmartRouterComponent(Component):
                         f"Comparing '{categorization}' with category {i + 1}: route_category='{route_category}'"
                     )
 
+                    # Case-insensitive match
                     if categorization.lower() == route_category.lower():
                         matched_category = i
                         self.status = f"MATCH FOUND! Category {i + 1} matched with '{categorization}'"
@@ -286,17 +320,23 @@ class SmartRouterComponent(Component):
         if llm and categories:
             try:
                 # Create prompt for categorization
-                category_values = [
-                    category.get("route_category", f"Category {i + 1}") for i, category in enumerate(categories)
-                ]
-                categories_text = ", ".join([f'"{cat}"' for cat in category_values if cat])
+                category_info = []
+                for i, category in enumerate(categories):
+                    cat_name = category.get("route_category", f"Category {i + 1}")
+                    cat_desc = category.get("route_description", "")
+                    if cat_desc and cat_desc.strip():
+                        category_info.append(f'"{cat_name}": {cat_desc}')
+                    else:
+                        category_info.append(f'"{cat_name}"')
+
+                categories_text = "\n".join([f"- {info}" for info in category_info if info])
 
                 # Create base prompt
                 base_prompt = (
                     "You are a text classifier. Given the following text and categories, "
                     "determine which category best matches the text.\n\n"
                     f'Text to classify: "{input_text}"\n\n'
-                    f"Available categories: {categories_text}\n\n"
+                    f"Available categories:\n{categories_text}\n\n"
                     "Respond with ONLY the exact category name that best matches the text. "
                     'If none match well, respond with "NONE".\n\n'
                     "Category:"
@@ -307,7 +347,11 @@ class SmartRouterComponent(Component):
                 if custom_prompt and custom_prompt.strip():
                     self.status = "Using custom prompt as additional instructions (default check)"
                     # Format custom prompt with variables
-                    formatted_custom = custom_prompt.format(input_text=input_text, routes=categories_text)
+                    # For the routes variable, create a simpler format for custom prompt usage
+                    simple_routes = ", ".join(
+                        [f'"{cat.get("route_category", f"Category {i + 1}")}"' for i, cat in enumerate(categories)]
+                    )
+                    formatted_custom = custom_prompt.format(input_text=input_text, routes=simple_routes)
                     # Combine base prompt with custom instructions
                     prompt = f"{base_prompt}\n\nAdditional Instructions:\n{formatted_custom}"
                 else:

lfx/components/nvidia/nvidia.py

@@ -42,7 +42,7 @@ class NVIDIAModelComponent(LCModelComponent):
             info="The name of the NVIDIA model to use.",
             advanced=False,
             value=None,
-            options=[model.id for model in all_models],
+            options=sorted(model.id for model in all_models),
             combobox=True,
             refresh_button=True,
         ),
@@ -102,8 +102,8 @@ class NVIDIAModelComponent(LCModelComponent):
         model = ChatNVIDIA(base_url=self.base_url, api_key=self.api_key)
         if tool_model_enabled:
             tool_models = [m for m in model.get_available_models() if m.supports_tools]
-            return [m.id for m in tool_models]
-        return [m.id for m in model.available_models]
+            return sorted(m.id for m in tool_models)
+        return sorted(m.id for m in model.available_models)
 
     def update_build_config(self, build_config: dotdict, _field_value: Any, field_name: str | None = None):
         if field_name in {"model_name", "tool_model_enabled", "base_url", "api_key"}:

lfx/components/processing/__init__.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
     from lfx.components.processing.data_to_dataframe import DataToDataFrameComponent
     from lfx.components.processing.dataframe_operations import DataFrameOperationsComponent
     from lfx.components.processing.dataframe_to_toolset import DataFrameToToolsetComponent
+    from lfx.components.processing.dynamic_create_data import DynamicCreateDataComponent
     from lfx.components.processing.extract_key import ExtractDataKeyComponent
     from lfx.components.processing.filter_data import FilterDataComponent
     from lfx.components.processing.filter_data_values import DataFilterComponent
@@ -46,6 +47,7 @@ _dynamic_imports = {
     "DataToDataFrameComponent": "data_to_dataframe",
     "DataFrameOperationsComponent": "dataframe_operations",
     "DataFrameToToolsetComponent": "dataframe_to_toolset",
+    "DynamicCreateDataComponent": "dynamic_create_data",
     "ExtractDataKeyComponent": "extract_key",
     "FilterDataComponent": "filter_data",
     "DataFilterComponent": "filter_data_values",
@@ -77,6 +79,7 @@ __all__ = [
     "DataFrameToToolsetComponent",
     "DataOperationsComponent",
     "DataToDataFrameComponent",
+    "DynamicCreateDataComponent",
     "ExtractDataKeyComponent",
     "FilterDataComponent",
     "JSONCleaner",

lfx/components/processing/dynamic_create_data.py

@@ -0,0 +1,357 @@
+from typing import Any
+
+from lfx.custom import Component
+from lfx.io import (
+    BoolInput,
+    FloatInput,
+    HandleInput,
+    IntInput,
+    MultilineInput,
+    Output,
+    StrInput,
+    TableInput,
+)
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+
+
+class DynamicCreateDataComponent(Component):
+    display_name: str = "Dynamic Create Data"
+    description: str = "Dynamically create a Data with a specified number of fields."
+    name: str = "DynamicCreateData"
+    MAX_FIELDS = 15  # Define a constant for maximum number of fields
+    icon = "ListFilter"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    inputs = [
+        TableInput(
+            name="form_fields",
+            display_name="Input Configuration",
+            info=(
+                "Define the dynamic form fields. Each row creates a new input field "
+                "that can connect to other components."
+            ),
+            table_schema=[
+                {
+                    "name": "field_name",
+                    "display_name": "Field Name",
+                    "type": "str",
+                    "description": "Name for the field (used as both internal name and display label)",
+                },
+                {
+                    "name": "field_type",
+                    "display_name": "Field Type",
+                    "type": "str",
+                    "description": "Type of input field to create",
+                    "options": ["Text", "Data", "Number", "Handle", "Boolean"],
+                    "value": "Text",
+                },
+            ],
+            value=[],
+            real_time_refresh=True,
+        ),
+        BoolInput(
+            name="include_metadata",
+            display_name="Include Metadata",
+            info="Include form configuration metadata in the output.",
+            value=False,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Data", name="form_data", method="process_form"),
+        Output(display_name="Message", name="message", method="get_message"),
+    ]
+
+    def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:
+        """Update build configuration to add dynamic inputs that can connect to other components."""
+        if field_name == "form_fields":
+            # Clear existing dynamic inputs from build config
+            keys_to_remove = [key for key in build_config if key.startswith("dynamic_")]
+            for key in keys_to_remove:
+                del build_config[key]
+
+            # Add dynamic inputs based on table configuration
+            # Safety check to ensure field_value is not None and is iterable
+            if field_value is None:
+                field_value = []
+
+            for i, field_config in enumerate(field_value):
+                # Safety check to ensure field_config is not None
+                if field_config is None:
+                    continue
+
+                field_name = field_config.get("field_name", f"field_{i}")
+                display_name = field_name  # Use field_name as display_name
+                field_type_option = field_config.get("field_type", "Text")
+                default_value = ""  # All fields have empty default value
+                required = False  # All fields are optional by default
+                help_text = ""  # All fields have empty help text
+
+                # Map field type options to actual field types and input types
+                field_type_mapping = {
+                    "Text": {"field_type": "multiline", "input_types": ["Text", "Message"]},
+                    "Data": {"field_type": "data", "input_types": ["Data"]},
+                    "Number": {"field_type": "number", "input_types": ["Text", "Message"]},
+                    "Handle": {"field_type": "handle", "input_types": ["Text", "Data", "Message"]},
+                    "Boolean": {"field_type": "boolean", "input_types": None},
+                }
+
+                field_config_mapped = field_type_mapping.get(
+                    field_type_option, {"field_type": "text", "input_types": []}
+                )
+                if not isinstance(field_config_mapped, dict):
+                    field_config_mapped = {"field_type": "text", "input_types": []}
+                field_type = field_config_mapped["field_type"]
+                input_types_list = field_config_mapped["input_types"]
+
+                # Create the appropriate input type based on field_type
+                dynamic_input_name = f"dynamic_{field_name}"
+
+                if field_type == "text":
+                    if input_types_list:
+                        build_config[dynamic_input_name] = StrInput(
+                            name=dynamic_input_name,
+                            display_name=display_name,
+                            info=f"{help_text} (Can connect to: {', '.join(input_types_list)})",
+                            value=default_value,
+                            required=required,
+                            input_types=input_types_list,
+                        )
+                    else:
+                        build_config[dynamic_input_name] = StrInput(
+                            name=dynamic_input_name,
+                            display_name=display_name,
+                            info=help_text,
+                            value=default_value,
+                            required=required,
+                        )
+
+                elif field_type == "multiline":
+                    if input_types_list:
+                        build_config[dynamic_input_name] = MultilineInput(
+                            name=dynamic_input_name,
+                            display_name=display_name,
+                            info=f"{help_text} (Can connect to: {', '.join(input_types_list)})",
+                            value=default_value,
+                            required=required,
+                            input_types=input_types_list,
+                        )
+                    else:
+                        build_config[dynamic_input_name] = MultilineInput(
+                            name=dynamic_input_name,
+                            display_name=display_name,
+                            info=help_text,
+                            value=default_value,
+                            required=required,
+                        )
+
+                elif field_type == "number":
+                    try:
+                        default_int = int(default_value) if default_value else 0
+                    except ValueError:
+                        default_int = 0
+
+                    if input_types_list:
+                        build_config[dynamic_input_name] = IntInput(
+                            name=dynamic_input_name,
+                            display_name=display_name,
+                            info=f"{help_text} (Can connect to: {', '.join(input_types_list)})",
+                            value=default_int,
+                            required=required,
+                            input_types=input_types_list,
+                        )
+                    else:
+                        build_config[dynamic_input_name] = IntInput(
+                            name=dynamic_input_name,
+                            display_name=display_name,
+                            info=help_text,
+                            value=default_int,
+                            required=required,
+                        )
+
+                elif field_type == "float":
+                    try:
+                        default_float = float(default_value) if default_value else 0.0
+                    except ValueError:
+                        default_float = 0.0
+
+                    if input_types_list:
+                        build_config[dynamic_input_name] = FloatInput(
+                            name=dynamic_input_name,
+                            display_name=display_name,
+                            info=f"{help_text} (Can connect to: {', '.join(input_types_list)})",
+                            value=default_float,
+                            required=required,
+                            input_types=input_types_list,
+                        )
+                    else:
+                        build_config[dynamic_input_name] = FloatInput(
+                            name=dynamic_input_name,
+                            display_name=display_name,
+                            info=help_text,
+                            value=default_float,
+                            required=required,
+                        )
+
+                elif field_type == "boolean":
+                    default_bool = default_value.lower() in ["true", "1", "yes"] if default_value else False
+
+                    # Boolean fields don't use input_types parameter to avoid errors
+                    build_config[dynamic_input_name] = BoolInput(
+                        name=dynamic_input_name,
+                        display_name=display_name,
+                        info=help_text,
+                        value=default_bool,
+                        input_types=[],
+                        required=required,
+                    )
+
+                elif field_type == "handle":
+                    # HandleInput for generic data connections
+                    build_config[dynamic_input_name] = HandleInput(
+                        name=dynamic_input_name,
+                        display_name=display_name,
+                        info=f"{help_text} (Accepts: {', '.join(input_types_list) if input_types_list else 'Any'})",
+                        input_types=input_types_list if input_types_list else ["Data", "Text", "Message"],
+                        required=required,
+                    )
+
+                elif field_type == "data":
+                    # Specialized for Data type connections
+                    build_config[dynamic_input_name] = HandleInput(
+                        name=dynamic_input_name,
+                        display_name=display_name,
+                        info=f"{help_text} (Data input)",
+                        input_types=input_types_list if input_types_list else ["Data"],
+                        required=required,
+                    )
+
+                else:
+                    # Default to text input for unknown types
+                    build_config[dynamic_input_name] = StrInput(
+                        name=dynamic_input_name,
+                        display_name=display_name,
+                        info=f"{help_text} (Unknown type '{field_type}', defaulting to text)",
+                        value=default_value,
+                        required=required,
+                    )
+
+        return build_config
+
+    def get_dynamic_values(self) -> dict[str, Any]:
+        """Extract simple values from all dynamic inputs, handling both manual and connected inputs."""
+        dynamic_values = {}
+        connection_info = {}
+        form_fields = getattr(self, "form_fields", [])
+
+        for field_config in form_fields:
+            # Safety check to ensure field_config is not None
+            if field_config is None:
+                continue
+
+            field_name = field_config.get("field_name", "")
+            if field_name:
+                dynamic_input_name = f"dynamic_{field_name}"
+                value = getattr(self, dynamic_input_name, None)
+
+                # Extract simple values from connections or manual input
+                if value is not None:
+                    try:
+                        extracted_value = self._extract_simple_value(value)
+                        dynamic_values[field_name] = extracted_value
+
+                        # Determine connection type for status
+                        if hasattr(value, "text") and hasattr(value, "timestamp"):
+                            connection_info[field_name] = "Connected (Message)"
+                        elif hasattr(value, "data"):
+                            connection_info[field_name] = "Connected (Data)"
+                        elif isinstance(value, (str, int, float, bool, list, dict)):
+                            connection_info[field_name] = "Manual input"
+                        else:
+                            connection_info[field_name] = "Connected (Object)"
+
+                    except (AttributeError, TypeError, ValueError):
+                        # Fallback to string representation if all else fails
+                        dynamic_values[field_name] = str(value)
+                        connection_info[field_name] = "Error"
+                else:
+                    # Use empty default value if nothing connected
+                    dynamic_values[field_name] = ""
+                    connection_info[field_name] = "Empty default"
+
+        # Store connection info for status output
+        self._connection_info = connection_info
+        return dynamic_values
+
+    def _extract_simple_value(self, value: Any) -> Any:
+        """Extract the simplest, most useful value from any input type."""
+        # Handle None
+        if value is None:
+            return None
+
+        # Handle simple types directly
+        if isinstance(value, (str, int, float, bool)):
+            return value
+
+        # Handle lists and tuples - keep simple
+        if isinstance(value, (list, tuple)):
+            return [self._extract_simple_value(item) for item in value]
+
+        # Handle dictionaries - keep simple
+        if isinstance(value, dict):
+            return {str(k): self._extract_simple_value(v) for k, v in value.items()}
+
+        # Handle Message objects - extract only the text
+        if hasattr(value, "text"):
+            return str(value.text) if value.text is not None else ""
+
+        # Handle Data objects - extract the data content
+        if hasattr(value, "data") and value.data is not None:
+            return self._extract_simple_value(value.data)
+
+        # For any other object, convert to string
+        return str(value)
+
+    def process_form(self) -> Data:
+        """Process all dynamic form inputs and return clean data with just field values."""
+        # Get all dynamic values (just the key:value pairs)
+        dynamic_values = self.get_dynamic_values()
+
+        # Update status with connection info
+        connected_fields = len([v for v in getattr(self, "_connection_info", {}).values() if "Connected" in v])
+        total_fields = len(dynamic_values)
+
+        self.status = f"Form processed successfully. {connected_fields}/{total_fields} fields connected to components."
+
+        # Return clean Data object with just the field values
+        return Data(data=dynamic_values)
+
+    def get_message(self) -> Message:
+        """Return form data as a formatted text message."""
+        # Get all dynamic values
+        dynamic_values = self.get_dynamic_values()
+
+        if not dynamic_values:
+            return Message(text="No form data available")
+
+        # Format as text message
+        message_lines = ["📋 Form Data:"]
+        message_lines.append("=" * 40)
+
+        for field_name, value in dynamic_values.items():
+            # Use field_name as display_name
+            display_name = field_name
+
+            message_lines.append(f"• {display_name}: {value}")
+
+        message_lines.append("=" * 40)
+        message_lines.append(f"Total fields: {len(dynamic_values)}")
+
+        message_text = "\n".join(message_lines)
+        self.status = f"Message formatted with {len(dynamic_values)} fields"
+
+        return Message(text=message_text)