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

lfx/components/langwatch/langwatch.py

@@ -0,0 +1,278 @@
+import json
+import os
+from typing import Any
+
+import httpx
+
+from lfx.base.langwatch.utils import get_cached_evaluators
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import MultilineInput
+from lfx.io import (
+    BoolInput,
+    DropdownInput,
+    FloatInput,
+    IntInput,
+    MessageTextInput,
+    NestedDictInput,
+    Output,
+    SecretStrInput,
+)
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dotdict import dotdict
+
+
+class LangWatchComponent(Component):
+    display_name: str = "LangWatch Evaluator"
+    description: str = "Evaluates various aspects of language models using LangWatch's evaluation endpoints."
+    documentation: str = "https://docs.langwatch.ai/langevals/documentation/introduction"
+    icon: str = "Langwatch"
+    name: str = "LangWatchEvaluator"
+
+    inputs = [
+        DropdownInput(
+            name="evaluator_name",
+            display_name="Evaluator Name",
+            options=[],
+            required=True,
+            info="Select an evaluator.",
+            refresh_button=True,
+            real_time_refresh=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="LangWatch API Key",
+            required=True,
+            info="Enter your LangWatch API key.",
+        ),
+        MessageTextInput(
+            name="input",
+            display_name="Input",
+            required=False,
+            info="The input text for evaluation.",
+        ),
+        MessageTextInput(
+            name="output",
+            display_name="Output",
+            required=False,
+            info="The output text for evaluation.",
+        ),
+        MessageTextInput(
+            name="expected_output",
+            display_name="Expected Output",
+            required=False,
+            info="The expected output for evaluation.",
+        ),
+        MessageTextInput(
+            name="contexts",
+            display_name="Contexts",
+            required=False,
+            info="The contexts for evaluation (comma-separated).",
+        ),
+        IntInput(
+            name="timeout",
+            display_name="Timeout",
+            info="The maximum time (in seconds) allowed for the server to respond before timing out.",
+            value=30,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(name="evaluation_result", display_name="Evaluation Result", method="evaluate"),
+    ]
+
+    def set_evaluators(self, endpoint: str):
+        url = f"{endpoint}/api/evaluations/list"
+        self.evaluators = get_cached_evaluators(url)
+        if not self.evaluators or len(self.evaluators) == 0:
+            self.status = f"No evaluators found from {endpoint}"
+            msg = f"No evaluators found from {endpoint}"
+            raise ValueError(msg)
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
+        try:
+            logger.info(f"Updating build config. Field name: {field_name}, Field value: {field_value}")
+
+            if field_name is None or field_name == "evaluator_name":
+                self.evaluators = self.get_evaluators(os.getenv("LANGWATCH_ENDPOINT", "https://app.langwatch.ai"))
+                build_config["evaluator_name"]["options"] = list(self.evaluators.keys())
+
+                # Set a default evaluator if none is selected
+                if not getattr(self, "current_evaluator", None) and self.evaluators:
+                    self.current_evaluator = next(iter(self.evaluators))
+                    build_config["evaluator_name"]["value"] = self.current_evaluator
+
+                # Define default keys that should always be present
+                default_keys = ["code", "_type", "evaluator_name", "api_key", "input", "output", "timeout"]
+
+                if field_value and field_value in self.evaluators and self.current_evaluator != field_value:
+                    self.current_evaluator = field_value
+                    evaluator = self.evaluators[field_value]
+
+                    # Clear previous dynamic inputs
+                    keys_to_remove = [key for key in build_config if key not in default_keys]
+                    for key in keys_to_remove:
+                        del build_config[key]
+
+                    # Clear component's dynamic attributes
+                    for attr in list(self.__dict__.keys()):
+                        if attr not in default_keys and attr not in {
+                            "evaluators",
+                            "dynamic_inputs",
+                            "_code",
+                            "current_evaluator",
+                        }:
+                            delattr(self, attr)
+
+                    # Add new dynamic inputs
+                    self.dynamic_inputs = self.get_dynamic_inputs(evaluator)
+                    for name, input_config in self.dynamic_inputs.items():
+                        build_config[name] = input_config.to_dict()
+
+                    # Update required fields
+                    required_fields = {"api_key", "evaluator_name"}.union(evaluator.get("requiredFields", []))
+                    for key in build_config:
+                        if isinstance(build_config[key], dict):
+                            build_config[key]["required"] = key in required_fields
+
+                # Validate presence of default keys
+                missing_keys = [key for key in default_keys if key not in build_config]
+                if missing_keys:
+                    logger.warning(f"Missing required keys in build_config: {missing_keys}")
+                    # Add missing keys with default values
+                    for key in missing_keys:
+                        build_config[key] = {"value": None, "type": "str"}
+
+            # Ensure the current_evaluator is always set in the build_config
+            build_config["evaluator_name"]["value"] = self.current_evaluator
+
+            logger.info(f"Current evaluator set to: {self.current_evaluator}")
+
+        except (KeyError, AttributeError, ValueError) as e:
+            self.status = f"Error updating component: {e!s}"
+        return build_config
+
+    def get_dynamic_inputs(self, evaluator: dict[str, Any]):
+        try:
+            dynamic_inputs = {}
+
+            input_fields = [
+                field
+                for field in evaluator.get("requiredFields", []) + evaluator.get("optionalFields", [])
+                if field not in {"input", "output"}
+            ]
+
+            for field in input_fields:
+                input_params = {
+                    "name": field,
+                    "display_name": field.replace("_", " ").title(),
+                    "required": field in evaluator.get("requiredFields", []),
+                }
+                if field == "contexts":
+                    dynamic_inputs[field] = MultilineInput(**input_params, multiline=True)
+                else:
+                    dynamic_inputs[field] = MessageTextInput(**input_params)
+
+            settings = evaluator.get("settings", {})
+            for setting_name, setting_config in settings.items():
+                schema = evaluator.get("settings_json_schema", {}).get("properties", {}).get(setting_name, {})
+
+                input_params = {
+                    "name": setting_name,
+                    "display_name": setting_name.replace("_", " ").title(),
+                    "info": setting_config.get("description", ""),
+                    "required": False,
+                }
+
+                if schema.get("type") == "object":
+                    input_type = NestedDictInput
+                    input_params["value"] = schema.get("default", setting_config.get("default", {}))
+                elif schema.get("type") == "boolean":
+                    input_type = BoolInput
+                    input_params["value"] = schema.get("default", setting_config.get("default", False))
+                elif schema.get("type") == "number":
+                    is_float = isinstance(schema.get("default", setting_config.get("default")), float)
+                    input_type = FloatInput if is_float else IntInput
+                    input_params["value"] = schema.get("default", setting_config.get("default", 0))
+                elif "enum" in schema:
+                    input_type = DropdownInput
+                    input_params["options"] = schema["enum"]
+                    input_params["value"] = schema.get("default", setting_config.get("default"))
+                else:
+                    input_type = MessageTextInput
+                    default_value = schema.get("default", setting_config.get("default"))
+                    input_params["value"] = str(default_value) if default_value is not None else ""
+
+                dynamic_inputs[setting_name] = input_type(**input_params)
+
+        except (KeyError, AttributeError, ValueError, TypeError) as e:
+            self.status = f"Error creating dynamic inputs: {e!s}"
+            return {}
+        return dynamic_inputs
+
+    async def evaluate(self) -> Data:
+        if not self.api_key:
+            return Data(data={"error": "API key is required"})
+
+        self.set_evaluators(os.getenv("LANGWATCH_ENDPOINT", "https://app.langwatch.ai"))
+        self.dynamic_inputs = {}
+        if getattr(self, "current_evaluator", None) is None and self.evaluators:
+            self.current_evaluator = next(iter(self.evaluators))
+
+        # Prioritize evaluator_name if it exists
+        evaluator_name = getattr(self, "evaluator_name", None) or self.current_evaluator
+
+        if not evaluator_name:
+            if self.evaluators:
+                evaluator_name = next(iter(self.evaluators))
+                await logger.ainfo(f"No evaluator was selected. Using default: {evaluator_name}")
+            else:
+                return Data(
+                    data={"error": "No evaluator selected and no evaluators available. Please choose an evaluator."}
+                )
+
+        try:
+            evaluator = self.evaluators.get(evaluator_name)
+            if not evaluator:
+                return Data(data={"error": f"Selected evaluator '{evaluator_name}' not found."})
+
+            await logger.ainfo(f"Evaluating with evaluator: {evaluator_name}")
+
+            endpoint = f"/api/evaluations/{evaluator_name}/evaluate"
+            url = f"{os.getenv('LANGWATCH_ENDPOINT', 'https://app.langwatch.ai')}{endpoint}"
+
+            headers = {"Content-Type": "application/json", "X-Auth-Token": self.api_key}
+
+            payload = {
+                "data": {
+                    "input": self.input,
+                    "output": self.output,
+                    "expected_output": self.expected_output,
+                    "contexts": self.contexts.split(",") if self.contexts else [],
+                },
+                "settings": {},
+            }
+
+            if self._tracing_service:
+                tracer = self._tracing_service.get_tracer("langwatch")
+                if tracer is not None and hasattr(tracer, "trace_id"):
+                    payload["settings"]["trace_id"] = str(tracer.trace_id)
+
+            for setting_name in self.dynamic_inputs:
+                payload["settings"][setting_name] = getattr(self, setting_name, None)
+
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(url, json=payload, headers=headers)
+
+            response.raise_for_status()
+            result = response.json()
+
+            formatted_result = json.dumps(result, indent=2)
+            self.status = f"Evaluation completed successfully. Result:\n{formatted_result}"
+            return Data(data=result)
+
+        except (httpx.RequestError, KeyError, AttributeError, ValueError) as e:
+            error_message = f"Evaluation error: {e!s}"
+            self.status = error_message
+            return Data(data={"error": error_message})

lfx/components/link_extractors/__init__.py

@@ -0,0 +1,3 @@
+"""LangFlow link extractors components."""
+
+__all__: list[str] = []

lfx/components/llm_operations/__init__.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.llm_operations.batch_run import BatchRunComponent
+    from lfx.components.llm_operations.lambda_filter import SmartTransformComponent
+    from lfx.components.llm_operations.llm_conditional_router import SmartRouterComponent
+    from lfx.components.llm_operations.llm_selector import LLMSelectorComponent
+    from lfx.components.llm_operations.structured_output import StructuredOutputComponent
+
+_dynamic_imports = {
+    "BatchRunComponent": "batch_run",
+    "SmartTransformComponent": "lambda_filter",
+    "SmartRouterComponent": "llm_conditional_router",
+    "LLMSelectorComponent": "llm_selector",
+    "StructuredOutputComponent": "structured_output",
+}
+
+__all__ = [
+    "BatchRunComponent",
+    "LLMSelectorComponent",
+    "SmartRouterComponent",
+    "SmartTransformComponent",
+    "StructuredOutputComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import LLM operation components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/llm_operations/batch_run.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+import toml  # type: ignore[import-untyped]
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import BoolInput, DataFrameInput, HandleInput, MessageTextInput, MultilineInput, Output
+from lfx.log.logger import logger
+from lfx.schema.dataframe import DataFrame
+
+if TYPE_CHECKING:
+    from langchain_core.runnables import Runnable
+
+
+class BatchRunComponent(Component):
+    display_name = "Batch Run"
+    description = "Runs an LLM on each row of a DataFrame column. If no column is specified, all columns are used."
+    documentation: str = "https://docs.langflow.org/batch-run"
+    icon = "List"
+
+    inputs = [
+        HandleInput(
+            name="model",
+            display_name="Language Model",
+            info="Connect the 'Language Model' output from your LLM component here.",
+            input_types=["LanguageModel"],
+            required=True,
+        ),
+        MultilineInput(
+            name="system_message",
+            display_name="Instructions",
+            info="Multi-line system instruction for all rows in the DataFrame.",
+            required=False,
+        ),
+        DataFrameInput(
+            name="df",
+            display_name="DataFrame",
+            info="The DataFrame whose column (specified by 'column_name') we'll treat as text messages.",
+            required=True,
+        ),
+        MessageTextInput(
+            name="column_name",
+            display_name="Column Name",
+            info=(
+                "The name of the DataFrame column to treat as text messages. "
+                "If empty, all columns will be formatted in TOML."
+            ),
+            required=False,
+            advanced=False,
+        ),
+        MessageTextInput(
+            name="output_column_name",
+            display_name="Output Column Name",
+            info="Name of the column where the model's response will be stored.",
+            value="model_response",
+            required=False,
+            advanced=True,
+        ),
+        BoolInput(
+            name="enable_metadata",
+            display_name="Enable Metadata",
+            info="If True, add metadata to the output DataFrame.",
+            value=False,
+            required=False,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="LLM Results",
+            name="batch_results",
+            method="run_batch",
+            info="A DataFrame with all original columns plus the model's response column.",
+        ),
+    ]
+
+    def _format_row_as_toml(self, row: dict[str, Any]) -> str:
+        """Convert a dictionary (row) into a TOML-formatted string."""
+        formatted_dict = {str(col): {"value": str(val)} for col, val in row.items()}
+        return toml.dumps(formatted_dict)
+
+    def _create_base_row(
+        self, original_row: dict[str, Any], model_response: str = "", batch_index: int = -1
+    ) -> dict[str, Any]:
+        """Create a base row with original columns and additional metadata."""
+        row = original_row.copy()
+        row[self.output_column_name] = model_response
+        row["batch_index"] = batch_index
+        return row
+
+    def _add_metadata(
+        self, row: dict[str, Any], *, success: bool = True, system_msg: str = "", error: str | None = None
+    ) -> None:
+        """Add metadata to a row if enabled."""
+        if not self.enable_metadata:
+            return
+
+        if success:
+            row["metadata"] = {
+                "has_system_message": bool(system_msg),
+                "input_length": len(row.get("text_input", "")),
+                "response_length": len(row[self.output_column_name]),
+                "processing_status": "success",
+            }
+        else:
+            row["metadata"] = {
+                "error": error,
+                "processing_status": "failed",
+            }
+
+    async def run_batch(self) -> DataFrame:
+        """Process each row in df[column_name] with the language model asynchronously.
+
+        Returns:
+            DataFrame: A new DataFrame containing:
+                - All original columns
+                - The model's response column (customizable name)
+                - 'batch_index' column for processing order
+                - 'metadata' (optional)
+
+        Raises:
+            ValueError: If the specified column is not found in the DataFrame
+            TypeError: If the model is not compatible or input types are wrong
+        """
+        model: Runnable = self.model
+        system_msg = self.system_message or ""
+        df: DataFrame = self.df
+        col_name = self.column_name or ""
+
+        # Validate inputs first
+        if not isinstance(df, DataFrame):
+            msg = f"Expected DataFrame input, got {type(df)}"
+            raise TypeError(msg)
+
+        if col_name and col_name not in df.columns:
+            msg = f"Column '{col_name}' not found in the DataFrame. Available columns: {', '.join(df.columns)}"
+            raise ValueError(msg)
+
+        try:
+            # Determine text input for each row
+            if col_name:
+                user_texts = df[col_name].astype(str).tolist()
+            else:
+                user_texts = [
+                    self._format_row_as_toml(cast("dict[str, Any]", row)) for row in df.to_dict(orient="records")
+                ]
+
+            total_rows = len(user_texts)
+            await logger.ainfo(f"Processing {total_rows} rows with batch run")
+
+            # Prepare the batch of conversations
+            conversations = [
+                [{"role": "system", "content": system_msg}, {"role": "user", "content": text}]
+                if system_msg
+                else [{"role": "user", "content": text}]
+                for text in user_texts
+            ]
+
+            # Configure the model with project info and callbacks
+            model = model.with_config(
+                {
+                    "run_name": self.display_name,
+                    "project_name": self.get_project_name(),
+                    "callbacks": self.get_langchain_callbacks(),
+                }
+            )
+            # Process batches and track progress
+            responses_with_idx = list(
+                zip(
+                    range(len(conversations)),
+                    await model.abatch(list(conversations)),
+                    strict=True,
+                )
+            )
+
+            # Sort by index to maintain order
+            responses_with_idx.sort(key=lambda x: x[0])
+
+            # Build the final data with enhanced metadata
+            rows: list[dict[str, Any]] = []
+            for idx, (original_row, response) in enumerate(
+                zip(df.to_dict(orient="records"), responses_with_idx, strict=False)
+            ):
+                response_text = response[1].content if hasattr(response[1], "content") else str(response[1])
+                row = self._create_base_row(
+                    cast("dict[str, Any]", original_row), model_response=response_text, batch_index=idx
+                )
+                self._add_metadata(row, success=True, system_msg=system_msg)
+                rows.append(row)
+
+                # Log progress
+                if (idx + 1) % max(1, total_rows // 10) == 0:
+                    await logger.ainfo(f"Processed {idx + 1}/{total_rows} rows")
+
+            await logger.ainfo("Batch processing completed successfully")
+            return DataFrame(rows)
+
+        except (KeyError, AttributeError) as e:
+            # Handle data structure and attribute access errors
+            await logger.aerror(f"Data processing error: {e!s}")
+            error_row = self._create_base_row(dict.fromkeys(df.columns, ""), model_response="", batch_index=-1)
+            self._add_metadata(error_row, success=False, error=str(e))
+            return DataFrame([error_row])