lfx-nightly 0.2.0.dev0__py3-none-any.whl → 0.2.0.dev41__py3-none-any.whl

lfx/components/models/language_model.py

@@ -1,144 +0,0 @@
-from typing import Any
-
-from langchain_anthropic import ChatAnthropic
-from langchain_openai import ChatOpenAI
-
-from lfx.base.models.anthropic_constants import ANTHROPIC_MODELS
-from lfx.base.models.google_generative_ai_constants import GOOGLE_GENERATIVE_AI_MODELS
-from lfx.base.models.google_generative_ai_model import ChatGoogleGenerativeAIFixed
-from lfx.base.models.model import LCModelComponent
-from lfx.base.models.openai_constants import OPENAI_CHAT_MODEL_NAMES, OPENAI_REASONING_MODEL_NAMES
-from lfx.field_typing import LanguageModel
-from lfx.field_typing.range_spec import RangeSpec
-from lfx.inputs.inputs import BoolInput
-from lfx.io import DropdownInput, MessageInput, MultilineInput, SecretStrInput, SliderInput
-from lfx.schema.dotdict import dotdict
-
-
-class LanguageModelComponent(LCModelComponent):
-    display_name = "Language Model"
-    description = "Runs a language model given a specified provider."
-    documentation: str = "https://docs.langflow.org/components-models"
-    icon = "brain-circuit"
-    category = "models"
-    priority = 0  # Set priority to 0 to make it appear first
-
-    inputs = [
-        DropdownInput(
-            name="provider",
-            display_name="Model Provider",
-            options=["OpenAI", "Anthropic", "Google"],
-            value="OpenAI",
-            info="Select the model provider",
-            real_time_refresh=True,
-            options_metadata=[{"icon": "OpenAI"}, {"icon": "Anthropic"}, {"icon": "GoogleGenerativeAI"}],
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            options=OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES,
-            value=OPENAI_CHAT_MODEL_NAMES[0],
-            info="Select the model to use",
-            real_time_refresh=True,
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="OpenAI API Key",
-            info="Model Provider API key",
-            required=False,
-            show=True,
-            real_time_refresh=True,
-        ),
-        MessageInput(
-            name="input_value",
-            display_name="Input",
-            info="The input text to send to the model",
-        ),
-        MultilineInput(
-            name="system_message",
-            display_name="System Message",
-            info="A system message that helps set the behavior of the assistant",
-            advanced=False,
-        ),
-        BoolInput(
-            name="stream",
-            display_name="Stream",
-            info="Whether to stream the response",
-            value=False,
-            advanced=True,
-        ),
-        SliderInput(
-            name="temperature",
-            display_name="Temperature",
-            value=0.1,
-            info="Controls randomness in responses",
-            range_spec=RangeSpec(min=0, max=1, step=0.01),
-            advanced=True,
-        ),
-    ]
-
-    def build_model(self) -> LanguageModel:
-        provider = self.provider
-        model_name = self.model_name
-        temperature = self.temperature
-        stream = self.stream
-
-        if provider == "OpenAI":
-            if not self.api_key:
-                msg = "OpenAI API key is required when using OpenAI provider"
-                raise ValueError(msg)
-
-            if model_name in OPENAI_REASONING_MODEL_NAMES:
-                # reasoning models do not support temperature (yet)
-                temperature = None
-
-            return ChatOpenAI(
-                model_name=model_name,
-                temperature=temperature,
-                streaming=stream,
-                openai_api_key=self.api_key,
-            )
-        if provider == "Anthropic":
-            if not self.api_key:
-                msg = "Anthropic API key is required when using Anthropic provider"
-                raise ValueError(msg)
-            return ChatAnthropic(
-                model=model_name,
-                temperature=temperature,
-                streaming=stream,
-                anthropic_api_key=self.api_key,
-            )
-        if provider == "Google":
-            if not self.api_key:
-                msg = "Google API key is required when using Google provider"
-                raise ValueError(msg)
-            return ChatGoogleGenerativeAIFixed(
-                model=model_name,
-                temperature=temperature,
-                streaming=stream,
-                google_api_key=self.api_key,
-            )
-        msg = f"Unknown provider: {provider}"
-        raise ValueError(msg)
-
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
-        if field_name == "provider":
-            if field_value == "OpenAI":
-                build_config["model_name"]["options"] = OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES
-                build_config["model_name"]["value"] = OPENAI_CHAT_MODEL_NAMES[0]
-                build_config["api_key"]["display_name"] = "OpenAI API Key"
-            elif field_value == "Anthropic":
-                build_config["model_name"]["options"] = ANTHROPIC_MODELS
-                build_config["model_name"]["value"] = ANTHROPIC_MODELS[0]
-                build_config["api_key"]["display_name"] = "Anthropic API Key"
-            elif field_value == "Google":
-                build_config["model_name"]["options"] = GOOGLE_GENERATIVE_AI_MODELS
-                build_config["model_name"]["value"] = GOOGLE_GENERATIVE_AI_MODELS[0]
-                build_config["api_key"]["display_name"] = "Google API Key"
-        elif field_name == "model_name" and field_value.startswith("o1") and self.provider == "OpenAI":
-            # Hide system_message for o1 models - currently unsupported
-            if "system_message" in build_config:
-                build_config["system_message"]["show"] = False
-        elif field_name == "model_name" and not field_value.startswith("o1") and "system_message" in build_config:
-            build_config["system_message"]["show"] = True
-        return build_config

lfx/components/processing/dataframe_to_toolset.py

@@ -1,259 +0,0 @@
-"""DataFrame to Toolset Component.
-
-This component converts each row of a DataFrame into a callable tool/action within a toolset.
-Each row becomes a tool where the action name comes from one column and the content/response
-comes from another column.
-"""
-
-from __future__ import annotations
-
-import re
-from typing import TYPE_CHECKING
-
-from langchain.tools import StructuredTool
-from pydantic import BaseModel, create_model
-
-from lfx.base.langchain_utilities.model import LCToolComponent
-from lfx.field_typing.constants import Tool
-from lfx.io import HandleInput, Output, StrInput
-from lfx.schema.data import Data
-from lfx.schema.dataframe import DataFrame
-from lfx.schema.message import Message
-
-if TYPE_CHECKING:
-    from lfx.field_typing.constants import Tool
-
-
-class DataFrameToToolsetComponent(LCToolComponent):
-    """Component that converts DataFrame rows into a toolset with multiple callable actions."""
-
-    display_name = "DataFrame to Toolset"
-    description = "Convert each row of a DataFrame into a callable tool/action in a toolset."
-    icon = "wrench"
-    name = "DataFrameToToolset"
-
-    inputs = [
-        HandleInput(
-            name="dataframe",
-            display_name="DataFrame",
-            input_types=["DataFrame"],
-            info="DataFrame where each row will become a tool/action",
-            required=True,
-        ),
-        StrInput(
-            name="tool_name_column",
-            display_name="Tool Name Column",
-            info="Column with tool names",
-            required=True,
-        ),
-        StrInput(
-            name="tool_output_column",
-            display_name="Tool Output Column",
-            info="Column with tool outputs/responses",
-            required=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Tools", name="tools", method="build_tools"),
-        Output(display_name="Message", name="message", method="get_message"),
-    ]
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self._tools_cache: list[Tool] = []
-        self._action_data: dict[str, dict[str, str]] = {}
-
-    def _sanitize_tool_name(self, name: str) -> str:
-        """Sanitize tool name to match required format '^[a-zA-Z0-9_-]+$'."""
-        # Replace any non-alphanumeric characters (except _ and -) with underscores
-        sanitized = re.sub(r"[^a-zA-Z0-9_-]", "_", str(name))
-        # Ensure it starts with a letter or underscore
-        if sanitized and not sanitized[0].isalpha() and sanitized[0] != "_":
-            sanitized = f"tool_{sanitized}"
-        return sanitized or "unnamed_tool"
-
-    def _prepare_action_data(self) -> None:
-        """Prepare action data from DataFrame."""
-        # Check if dataframe exists and is valid
-        if not hasattr(self, "dataframe") or self.dataframe is None:
-            self._action_data = {}
-            return
-
-        if not isinstance(self.dataframe, DataFrame):
-            self._action_data = {}
-            return
-
-        if not hasattr(self.dataframe, "columns"):
-            self._action_data = {}
-            return
-
-        # Check if column names are provided
-        if not self.tool_name_column or not self.tool_output_column:
-            self._action_data = {}
-            return
-
-        if self.tool_name_column not in self.dataframe.columns:
-            msg = (
-                f"Tool name column '{self.tool_name_column}' not found in DataFrame columns: "
-                f"{list(self.dataframe.columns)}"
-            )
-            raise ValueError(msg)
-
-        if self.tool_output_column not in self.dataframe.columns:
-            msg = (
-                f"Tool output column '{self.tool_output_column}' not found in DataFrame columns: "
-                f"{list(self.dataframe.columns)}"
-            )
-            raise ValueError(msg)
-
-        # Clear previous data
-        self._action_data = {}
-
-        # Process each row to create action mappings
-        for _, row in self.dataframe.iterrows():
-            action_name = str(row[self.tool_name_column]).strip()
-            content = str(row[self.tool_output_column]).strip()
-
-            if action_name and content:
-                sanitized_name = self._sanitize_tool_name(action_name)
-                self._action_data[sanitized_name] = {
-                    "original_name": action_name,
-                    "content": content,
-                    "sanitized_name": sanitized_name,
-                }
-
-    def _create_action_function(self, action_name: str, content: str):
-        """Create a function for a specific action that returns the content."""
-
-        def action_function(**kwargs) -> str:
-            # You could extend this to use kwargs to modify the content
-            # For now, just return the stored content
-            self.log(kwargs)  # TODO: Coming soon: implement arguments to modify content
-            return content
-
-        action_function.__name__ = f"execute_{action_name}"
-        action_function.__doc__ = f"Execute {action_name} action and return the associated content."
-        return action_function
-
-    def build_tools(self) -> list[Tool]:
-        """Build the toolset from DataFrame data."""
-        # Handle case where inputs are not ready
-        if not hasattr(self, "dataframe") or self.dataframe is None:
-            return []
-
-        self._prepare_action_data()
-
-        if not self._action_data:
-            return []
-
-        tools_description_preview_length = 100
-        tools_description_content_length = 200
-
-        tools = []
-
-        for sanitized_name, action_info in self._action_data.items():
-            original_name = action_info["original_name"]
-            content = action_info["content"]
-
-            # Create a simple schema for this tool (no parameters needed)
-            # But we could extend this to accept parameters if needed
-            tool_schema = create_model(
-                f"{sanitized_name}Schema",
-                __base__=BaseModel,
-                # Add parameters here if you want the tools to accept inputs
-                # For now, keeping it simple with no parameters
-            )
-
-            # Create the tool function
-            tool_function = self._create_action_function(sanitized_name, content)
-
-            # Create the StructuredTool
-            tool = StructuredTool(
-                name=sanitized_name,
-                description=(
-                    f"Execute {original_name} action. Returns: "
-                    f"{content[:tools_description_preview_length]}"
-                    f"{'...' if len(content) > tools_description_preview_length else ''}"
-                ),
-                func=tool_function,
-                args_schema=tool_schema,
-                handle_tool_error=True,
-                tags=[sanitized_name],
-                metadata={
-                    "display_name": original_name,
-                    "display_description": f"Action: {original_name}",
-                    "original_name": original_name,
-                    "content_preview": content[:tools_description_content_length],
-                },
-            )
-
-            tools.append(tool)
-
-        self._tools_cache = tools
-        return tools
-
-    def build_tool(self) -> Tool:
-        """Build a single tool (for compatibility with LCToolComponent)."""
-        tools = self.build_tools()
-        if not tools:
-            # Return a placeholder tool when no data is available
-            def placeholder_function(**kwargs) -> str:
-                self.log(kwargs)  # TODO: Coming soon: implement arguments to modify content
-                return "No tools available. Please connect a DataFrame with appropriate columns."
-
-            return StructuredTool(
-                name="placeholder_tool",
-                description="Placeholder tool - waiting for DataFrame input",
-                func=placeholder_function,
-                args_schema=create_model("PlaceholderSchema", __base__=BaseModel),
-            )
-
-        # Return the first tool, or create a composite tool
-        return tools[0]
-
-    def get_message(self) -> Message:
-        """Get a message describing the created toolset."""
-        # Handle case where inputs are not ready
-        if not hasattr(self, "dataframe") or self.dataframe is None:
-            return Message(text="Waiting for DataFrame input...")
-
-        self._prepare_action_data()
-
-        if not self._action_data:
-            return Message(text="No tools were created. Please check your DataFrame and column selections.")
-
-        tool_count = len(self._action_data)
-        tool_names = [info["original_name"] for info in self._action_data.values()]
-
-        message_text = f"Created toolset with {tool_count} tools:\n"
-        for i, name in enumerate(tool_names, 1):
-            message_text += f"{i}. {name}\n"
-
-        return Message(text=message_text)
-
-    def run_model(self) -> list[Data]:
-        """Run the model and return tool information as Data objects."""
-        # Handle case where inputs are not ready
-        if not hasattr(self, "dataframe") or self.dataframe is None:
-            return [Data(data={"status": "Waiting for DataFrame input"})]
-
-        tools = self.build_tools()
-
-        if not tools:
-            return [Data(data={"status": "No tools created. Check DataFrame and column selections."})]
-
-        results = []
-        for tool in tools:
-            tool_data = {
-                "tool_name": tool.name,
-                "display_name": tool.metadata.get("display_name", tool.name)
-                if hasattr(tool, "metadata")
-                else tool.name,
-                "description": tool.description,
-                "original_name": tool.metadata.get("original_name", "") if hasattr(tool, "metadata") else "",
-                "content_preview": tool.metadata.get("content_preview", "") if hasattr(tool, "metadata") else "",
-            }
-            results.append(Data(data=tool_data))
-
-        return results