lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/components/llm_operations/lambda_filter.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import TYPE_CHECKING, Any
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import DataInput, HandleInput, IntInput, MultilineInput, Output
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class LambdaFilterComponent(Component):
+    display_name = "Smart Transform"
+    description = "Uses an LLM to generate a function for filtering or transforming structured data."
+    documentation: str = "https://docs.langflow.org/smart-transform"
+    icon = "square-function"
+    name = "Smart Transform"
+
+    inputs = [
+        DataInput(
+            name="data",
+            display_name="Data",
+            info="The structured data to filter or transform using a lambda function.",
+            input_types=["Data", "DataFrame"],
+            is_list=True,
+            required=True,
+        ),
+        HandleInput(
+            name="llm",
+            display_name="Language Model",
+            info="Connect the 'Language Model' output from your LLM component here.",
+            input_types=["LanguageModel"],
+            required=True,
+        ),
+        MultilineInput(
+            name="filter_instruction",
+            display_name="Instructions",
+            info=(
+                "Natural language instructions for how to filter or transform the data using a lambda function. "
+                "Example: Filter the data to only include items where the 'status' is 'active'."
+            ),
+            value="Filter the data to...",
+            required=True,
+        ),
+        IntInput(
+            name="sample_size",
+            display_name="Sample Size",
+            info="For large datasets, number of items to sample from head/tail.",
+            value=1000,
+            advanced=True,
+        ),
+        IntInput(
+            name="max_size",
+            display_name="Max Size",
+            info="Number of characters for the data to be considered large.",
+            value=30000,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Output",
+            name="data_output",
+            method="process_as_data",
+        ),
+        Output(
+            display_name="Output",
+            name="dataframe_output",
+            method="process_as_dataframe",
+        ),
+    ]
+
+    def get_data_structure(self, data):
+        """Extract the structure of data, replacing values with their types."""
+        if isinstance(data, list):
+            # For lists, get structure of first item if available
+            if data:
+                return [self.get_data_structure(data[0])]
+            return []
+        if isinstance(data, dict):
+            return {k: self.get_data_structure(v) for k, v in data.items()}
+        # For primitive types, return the type name
+        return type(data).__name__
+
+    def _validate_lambda(self, lambda_text: str) -> bool:
+        """Validate the provided lambda function text."""
+        # Return False if the lambda function does not start with 'lambda' or does not contain a colon
+        return lambda_text.strip().startswith("lambda") and ":" in lambda_text
+
+    async def _execute_lambda(self) -> Any:
+        self.log(str(self.data))
+
+        # Convert input to a unified format
+        if isinstance(self.data, list):
+            # Handle list of Data or DataFrame objects
+            combined_data = []
+            for item in self.data:
+                if isinstance(item, DataFrame):
+                    # DataFrame to list of dicts
+                    combined_data.extend(item.to_dict(orient="records"))
+                elif hasattr(item, "data"):
+                    # Data object
+                    if isinstance(item.data, dict):
+                        combined_data.append(item.data)
+                    elif isinstance(item.data, list):
+                        combined_data.extend(item.data)
+
+            # If we have a single dict, unwrap it so lambdas can access it directly
+            if len(combined_data) == 1 and isinstance(combined_data[0], dict):
+                data = combined_data[0]
+            elif len(combined_data) == 0:
+                data = {}
+            else:
+                data = combined_data  # type: ignore[assignment]
+        elif isinstance(self.data, DataFrame):
+            # Single DataFrame to list of dicts
+            data = self.data.to_dict(orient="records")
+        elif hasattr(self.data, "data"):
+            # Single Data object
+            data = self.data.data
+        else:
+            data = self.data
+
+        dump = json.dumps(data)
+        self.log(str(data))
+
+        llm = self.llm
+        instruction = self.filter_instruction
+        sample_size = self.sample_size
+
+        # Get data structure and samples
+        data_structure = self.get_data_structure(data)
+        dump_structure = json.dumps(data_structure)
+        self.log(dump_structure)
+
+        # For large datasets, sample from head and tail
+        if len(dump) > self.max_size:
+            data_sample = (
+                f"Data is too long to display... \n\n First lines (head): {dump[:sample_size]} \n\n"
+                f" Last lines (tail): {dump[-sample_size:]})"
+            )
+        else:
+            data_sample = dump
+
+        self.log(data_sample)
+
+        prompt = f"""Given this data structure and examples, create a Python lambda function that
+                    implements the following instruction:
+
+                    Data Structure:
+                    {dump_structure}
+
+                    Example Items:
+                    {data_sample}
+
+                    Instruction: {instruction}
+
+                    Return ONLY the lambda function and nothing else. No need for ```python or whatever.
+                    Just a string starting with lambda.
+                    """
+
+        response = await llm.ainvoke(prompt)
+        response_text = response.content if hasattr(response, "content") else str(response)
+        self.log(response_text)
+
+        # Extract lambda using regex
+        lambda_match = re.search(r"lambda\s+\w+\s*:.*?(?=\n|$)", response_text)
+        if not lambda_match:
+            msg = f"Could not find lambda in response: {response_text}"
+            raise ValueError(msg)
+
+        lambda_text = lambda_match.group().strip()
+        self.log(lambda_text)
+
+        # Validation is commented out as requested
+        if not self._validate_lambda(lambda_text):
+            msg = f"Invalid lambda format: {lambda_text}"
+            raise ValueError(msg)
+
+        # Create and apply the function
+        fn: Callable[[Any], Any] = eval(lambda_text)  # noqa: S307
+
+        # Apply the lambda function to the data
+        return fn(data)
+
+    async def process_as_data(self) -> Data:
+        """Process the data and return as a Data object."""
+        result = await self._execute_lambda()
+
+        # Convert result to Data based on type
+        if isinstance(result, dict):
+            return Data(data=result)
+        if isinstance(result, list):
+            return Data(data={"_results": result})
+        # For other types, convert to string
+        return Data(data={"text": str(result)})
+
+    async def process_as_dataframe(self) -> DataFrame:
+        """Process the data and return as a DataFrame."""
+        result = await self._execute_lambda()
+
+        # Convert result to DataFrame based on type
+        if isinstance(result, list):
+            # Check if it's a list of dicts
+            if all(isinstance(item, dict) for item in result):
+                return DataFrame(result)
+            # List of non-dicts: wrap each value
+            return DataFrame([{"value": item} for item in result])
+        if isinstance(result, dict):
+            # Single dict becomes single-row DataFrame
+            return DataFrame([result])
+        # Other types: convert to string and wrap
+        return DataFrame([{"value": str(result)}])

lfx/components/llm_operations/llm_conditional_router.py

@@ -0,0 +1,421 @@
+from typing import Any
+
+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):
+    display_name = "Smart Router"
+    description = "Routes an input message using LLM-based categorization."
+    icon = "route"
+    name = "SmartRouter"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._matched_category = None
+
+    inputs = [
+        HandleInput(
+            name="llm",
+            display_name="Language Model",
+            info="LLM to use for categorization.",
+            input_types=["LanguageModel"],
+            required=True,
+        ),
+        MessageTextInput(
+            name="input_text",
+            display_name="Input",
+            info="The primary text input for the operation.",
+            required=True,
+        ),
+        TableInput(
+            name="routes",
+            display_name="Routes",
+            info=(
+                "Define the categories for routing. Each row should have a route/category name "
+                "and optionally a custom output value."
+            ),
+            table_schema=[
+                {
+                    "name": "route_category",
+                    "display_name": "Route Name",
+                    "type": "str",
+                    "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": "Route Message (Optional)",
+                    "type": "str",
+                    "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",
+                    "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,
+        ),
+        MessageInput(
+            name="message",
+            display_name="Override Output",
+            info=(
+                "Optional override message that will replace both the Input and Output Value "
+                "for all routes when filled."
+            ),
+            required=False,
+            advanced=True,
+        ),
+        BoolInput(
+            name="enable_else_output",
+            display_name="Include Else Output",
+            info="Include an Else output for cases that don't match any route.",
+            value=False,
+            advanced=True,
+        ),
+        MultilineInput(
+            name="custom_prompt",
+            display_name="Additional Instructions",
+            info=(
+                "Additional instructions for LLM-based categorization. "
+                "These will be added to the base prompt. "
+                "Use {input_text} for the input text and {routes} for the available categories."
+            ),
+            advanced=True,
+        ),
+    ]
+
+    outputs: list[Output] = []
+
+    def update_outputs(self, frontend_node: dict, field_name: str, field_value: Any) -> dict:
+        """Create a dynamic output for each category in the categories table."""
+        if field_name in {"routes", "enable_else_output"}:
+            frontend_node["outputs"] = []
+
+            # Get the routes data - either from field_value (if routes field) or from component state
+            routes_data = field_value if field_name == "routes" else getattr(self, "routes", [])
+
+            # Add a dynamic output for each category - all using the same method
+            for i, row in enumerate(routes_data):
+                route_category = row.get("route_category", f"Category {i + 1}")
+                frontend_node["outputs"].append(
+                    Output(
+                        display_name=route_category,
+                        name=f"category_{i + 1}_result",
+                        method="process_case",
+                        group_outputs=True,
+                    )
+                )
+            # Add default output only if enabled
+            if field_name == "enable_else_output":
+                enable_else = field_value
+            else:
+                enable_else = getattr(self, "enable_else_output", False)
+
+            if enable_else:
+                frontend_node["outputs"].append(
+                    Output(display_name="Else", name="default_result", method="default_response", group_outputs=True)
+                )
+        return frontend_node
+
+    def process_case(self) -> Message:
+        """Process all categories using LLM categorization and return message for matching category."""
+        # Clear any previous match state
+        self._matched_category = None
+
+        # Get categories and input text
+        categories = getattr(self, "routes", [])
+        input_text = getattr(self, "input_text", "")
+
+        # Find the matching category using LLM-based categorization
+        matched_category = None
+        llm = getattr(self, "llm", None)
+
+        if llm and categories:
+            # Create prompt for categorization
+            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:\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:"
+            )
+
+            # Use custom prompt as additional instructions if provided
+            custom_prompt = getattr(self, "custom_prompt", "")
+            if custom_prompt and custom_prompt.strip():
+                self.status = "Using custom prompt as additional instructions"
+                # Format custom prompt with variables
+                # 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:
+                self.status = "Using default prompt for LLM categorization"
+                prompt = base_prompt
+
+            # Log the final prompt being sent to LLM
+            self.status = f"Prompt sent to LLM:\n{prompt}"
+
+            try:
+                # Use the LLM to categorize
+                if hasattr(llm, "invoke"):
+                    response = llm.invoke(prompt)
+                    if hasattr(response, "content"):
+                        categorization = response.content.strip().strip('"')
+                    else:
+                        categorization = str(response).strip().strip('"')
+                else:
+                    categorization = str(llm(prompt)).strip().strip('"')
+
+                # Log the categorization process
+                self.status = f"LLM response: '{categorization}'"
+
+                # Find matching category based on LLM response
+                for i, category in enumerate(categories):
+                    route_category = category.get("route_category", "")
+
+                    # Log each comparison attempt
+                    self.status = (
+                        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}'"
+                        break
+
+                if matched_category is None:
+                    self.status = (
+                        f"No match found for '{categorization}'. Available categories: "
+                        f"{[category.get('route_category', '') for category in categories]}"
+                    )
+
+            except RuntimeError as e:
+                self.status = f"Error in LLM categorization: {e!s}"
+        else:
+            self.status = "No LLM provided for categorization"
+
+        if matched_category is not None:
+            # Store the matched category for other outputs to check
+            self._matched_category = matched_category
+
+            # Stop all category outputs except the matched one
+            for i in range(len(categories)):
+                if i != matched_category:
+                    self.stop(f"category_{i + 1}_result")
+
+            # Also stop the default output (if it exists)
+            enable_else = getattr(self, "enable_else_output", False)
+            if enable_else:
+                self.stop("default_result")
+
+            route_category = categories[matched_category].get("route_category", f"Category {matched_category + 1}")
+            self.status = f"Categorized as {route_category}"
+
+            # Check if there's an override output (takes precedence over everything)
+            override_output = getattr(self, "message", None)
+            if (
+                override_output
+                and hasattr(override_output, "text")
+                and override_output.text
+                and str(override_output.text).strip()
+            ):
+                return Message(text=str(override_output.text))
+            if override_output and isinstance(override_output, str) and override_output.strip():
+                return Message(text=str(override_output))
+
+            # Check if there's a custom output value for this category
+            custom_output = categories[matched_category].get("output_value", "")
+            # Treat None, empty string, or whitespace as blank
+            if custom_output and str(custom_output).strip() and str(custom_output).strip().lower() != "none":
+                # Use custom output value
+                return Message(text=str(custom_output))
+            # Use input as default output
+            return Message(text=input_text)
+        # No match found, stop all category outputs
+        for i in range(len(categories)):
+            self.stop(f"category_{i + 1}_result")
+
+        # Check if else output is enabled
+        enable_else = getattr(self, "enable_else_output", False)
+        if enable_else:
+            # The default_response will handle the else case
+            self.stop("process_case")
+            return Message(text="")
+        # No else output, so no output at all
+        self.status = "No match found and Else output is disabled"
+        return Message(text="")
+
+    def default_response(self) -> Message:
+        """Handle the else case when no conditions match."""
+        # Check if else output is enabled
+        enable_else = getattr(self, "enable_else_output", False)
+        if not enable_else:
+            self.status = "Else output is disabled"
+            return Message(text="")
+
+        # Clear any previous match state if not already set
+        if not hasattr(self, "_matched_category"):
+            self._matched_category = None
+
+        categories = getattr(self, "routes", [])
+        input_text = getattr(self, "input_text", "")
+
+        # Check if a match was already found in process_case
+        if hasattr(self, "_matched_category") and self._matched_category is not None:
+            self.status = (
+                f"Match already found in process_case (Category {self._matched_category + 1}), "
+                "stopping default_response"
+            )
+            self.stop("default_result")
+            return Message(text="")
+
+        # Check if any category matches using LLM categorization
+        has_match = False
+        llm = getattr(self, "llm", None)
+
+        if llm and categories:
+            try:
+                # Create prompt for categorization
+                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:\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:"
+                )
+
+                # Use custom prompt as additional instructions if provided
+                custom_prompt = getattr(self, "custom_prompt", "")
+                if custom_prompt and custom_prompt.strip():
+                    self.status = "Using custom prompt as additional instructions (default check)"
+                    # Format custom prompt with variables
+                    # 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:
+                    self.status = "Using default prompt for LLM categorization (default check)"
+                    prompt = base_prompt
+
+                # Log the final prompt being sent to LLM for default check
+                self.status = f"Default check - Prompt sent to LLM:\n{prompt}"
+
+                # Use the LLM to categorize
+                if hasattr(llm, "invoke"):
+                    response = llm.invoke(prompt)
+                    if hasattr(response, "content"):
+                        categorization = response.content.strip().strip('"')
+                    else:
+                        categorization = str(response).strip().strip('"')
+                else:
+                    categorization = str(llm(prompt)).strip().strip('"')
+
+                # Log the categorization process for default check
+                self.status = f"Default check - LLM response: '{categorization}'"
+
+                # Check if LLM response matches any category
+                for i, category in enumerate(categories):
+                    route_category = category.get("route_category", "")
+
+                    # Log each comparison attempt
+                    self.status = (
+                        f"Default check - Comparing '{categorization}' with category {i + 1}: "
+                        f"route_category='{route_category}'"
+                    )
+
+                    if categorization.lower() == route_category.lower():
+                        has_match = True
+                        self.status = f"Default check - MATCH FOUND! Category {i + 1} matched with '{categorization}'"
+                        break
+
+                if not has_match:
+                    self.status = (
+                        f"Default check - No match found for '{categorization}'. "
+                        f"Available categories: "
+                        f"{[category.get('route_category', '') for category in categories]}"
+                    )
+
+            except RuntimeError:
+                pass  # If there's an error, treat as no match
+
+        if has_match:
+            # A case matches, stop this output
+            self.stop("default_result")
+            return Message(text="")
+
+        # No case matches, check for override output first, then use input as default
+        override_output = getattr(self, "message", None)
+        if (
+            override_output
+            and hasattr(override_output, "text")
+            and override_output.text
+            and str(override_output.text).strip()
+        ):
+            self.status = "Routed to Else (no match) - using override output"
+            return Message(text=str(override_output.text))
+        if override_output and isinstance(override_output, str) and override_output.strip():
+            self.status = "Routed to Else (no match) - using override output"
+            return Message(text=str(override_output))
+        self.status = "Routed to Else (no match) - using input as default"
+        return Message(text=input_text)