langflow-base-nightly 0.5.1.dev3__py3-none-any.whl → 0.5.1.dev5__py3-none-any.whl

langflow/base/models/model_metadata.py

@@ -1,41 +0,0 @@
-from typing import TypedDict
-
-
-class ModelMetadata(TypedDict, total=False):
-    """Simple model metadata structure."""
-
-    provider: str  # Provider name (e.g., "anthropic", "groq", "openai")
-    name: str  # Model name/ID
-    icon: str  # Icon name for UI
-    tool_calling: bool  # Whether model supports tool calling (defaults to False)
-    reasoning: bool  # Reasoning models (defaults to False)
-    search: bool  # Search models (defaults to False)
-    preview: bool  # Whether model is in preview/beta (defaults to False)
-    not_supported: bool  # Whether model is not supported or deprecated (defaults to False)
-    deprecated: bool  # Whether model is deprecated (defaults to False)
-
-
-def create_model_metadata(
-    provider: str,
-    name: str,
-    icon: str,
-    *,
-    tool_calling: bool = False,
-    reasoning: bool = False,
-    search: bool = False,
-    preview: bool = False,
-    not_supported: bool = False,
-    deprecated: bool = False,
-) -> ModelMetadata:
-    """Helper function to create ModelMetadata with explicit defaults."""
-    return ModelMetadata(
-        provider=provider,
-        name=name,
-        icon=icon,
-        tool_calling=tool_calling,
-        reasoning=reasoning,
-        search=search,
-        preview=preview,
-        not_supported=not_supported,
-        deprecated=deprecated,
-    )

langflow/base/models/model_utils.py

@@ -1,8 +0,0 @@
-def get_model_name(llm, display_name: str | None = "Custom"):
-    attributes_to_check = ["model_name", "model", "model_id", "deployment_name"]
-
-    # Use a generator expression with next() to find the first matching attribute
-    model_name = next((getattr(llm, attr) for attr in attributes_to_check if hasattr(llm, attr)), None)
-
-    # If no matching attribute is found, return the class name as a fallback
-    return model_name if model_name is not None else display_name

langflow/base/models/novita_constants.py

@@ -1,35 +0,0 @@
-NOVITA_MODELS = [
-    "deepseek/deepseek-r1",
-    "deepseek/deepseek_v3",
-    "meta-llama/llama-3.3-70b-instruct",
-    "meta-llama/llama-3.1-8b-instruct",
-    "meta-llama/llama-3.1-70b-instruct",
-    "mistralai/mistral-nemo",
-    "Sao10K/L3-8B-Stheno-v3.2",
-    "gryphe/mythomax-l2-13b",
-    "qwen/qwen-2.5-72b-instruct",
-    "meta-llama/llama-3-8b-instruct",
-    "microsoft/wizardlm-2-8x22b",
-    "google/gemma-2-9b-it",
-    "mistralai/mistral-7b-instruct",
-    "meta-llama/llama-3-70b-instruct",
-    "openchat/openchat-7b",
-    "nousresearch/hermes-2-pro-llama-3-8b",
-    "sao10k/l3-70b-euryale-v2.1",
-    "cognitivecomputations/dolphin-mixtral-8x22b",
-    "jondurbin/airoboros-l2-70b",
-    "nousresearch/nous-hermes-llama2-13b",
-    "teknium/openhermes-2.5-mistral-7b",
-    "sophosympatheia/midnight-rose-70b",
-    "meta-llama/llama-3.1-8b-instruct-max",
-    "sao10k/l3-8b-lunaris",
-    "qwen/qwen-2-vl-72b-instruct",
-    "meta-llama/llama-3.2-1b-instruct",
-    "meta-llama/llama-3.2-11b-vision-instruct",
-    "meta-llama/llama-3.2-3b-instruct",
-    "meta-llama/llama-3.1-8b-instruct-bf16",
-    "sao10k/l31-70b-euryale-v2.2",
-    "qwen/qwen-2-7b-instruct",
-    "qwen/qwen-2-72b-instruct",
-]
-MODEL_NAMES = NOVITA_MODELS  # reverse compatibility

langflow/base/models/ollama_constants.py

@@ -1,49 +0,0 @@
-# https://ollama.com/search?c=embedding
-OLLAMA_EMBEDDING_MODELS = [
-    "nomic-embed-text",
-    "mxbai-embed-large",
-    "snowflake-arctic-embed",
-    "all-minilm",
-    "bge-m3",
-    "bge-large",
-    "paraphrase-multilingual",
-    "granite-embedding",
-    "jina-embeddings-v2-base-en",
-]
-# https://ollama.com/search?c=tools
-OLLAMA_TOOL_MODELS_BASE = [
-    "llama3.3",
-    "qwq",
-    "llama3.2",
-    "llama3.1",
-    "mistral",
-    "qwen2",
-    "qwen2.5",
-    "qwen2.5-coder",
-    "mistral-nemo",
-    "mixtral",
-    "command-r",
-    "command-r-plus",
-    "mistral-large",
-    "smollm2",
-    "hermes3",
-    "athene-v2",
-    "mistral-small",
-    "nemotron-mini",
-    "nemotron",
-    "llama3-groq-tool-use",
-    "granite3-dense",
-    "granite3.1-dense",
-    "aya-expanse",
-    "granite3-moe",
-    "firefunction-v2",
-    "cogito",
-]
-
-
-URL_LIST = [
-    "http://localhost:11434",
-    "http://host.docker.internal:11434",
-    "http://127.0.0.1:11434",
-    "http://0.0.0.0:11434",
-]

langflow/base/models/sambanova_constants.py

@@ -1,18 +0,0 @@
-SAMBANOVA_MODEL_NAMES = [
-    "Meta-Llama-3.3-70B-Instruct",
-    "Meta-Llama-3.1-8B-Instruct",
-    "Meta-Llama-3.1-70B-Instruct",
-    "Meta-Llama-3.1-405B-Instruct",
-    "DeepSeek-R1-Distill-Llama-70B",
-    "DeepSeek-R1",
-    "Meta-Llama-3.2-1B-Instruct",
-    "Meta-Llama-3.2-3B-Instruct",
-    "Llama-3.2-11B-Vision-Instruct",
-    "Llama-3.2-90B-Vision-Instruct",
-    "Qwen2.5-Coder-32B-Instruct",
-    "Qwen2.5-72B-Instruct",
-    "QwQ-32B-Preview",
-    "Qwen2-Audio-7B-Instruct",
-]
-
-MODEL_NAMES = SAMBANOVA_MODEL_NAMES

langflow/base/prompts/utils.py

@@ -1,61 +0,0 @@
-from copy import deepcopy
-
-from langchain_core.documents import Document
-
-from langflow.schema.data import Data
-
-
-def data_to_string(record: Data) -> str:
-    """Convert a record to a string.
-
-    Args:
-        record (Data): The record to convert.
-
-    Returns:
-        str: The record as a string.
-    """
-    return record.get_text()
-
-
-def dict_values_to_string(d: dict) -> dict:
-    """Converts the values of a dictionary to strings.
-
-    Args:
-        d (dict): The dictionary whose values need to be converted.
-
-    Returns:
-        dict: The dictionary with values converted to strings.
-    """
-    from langflow.schema.message import Message
-
-    # Do something similar to the above
-    d_copy = deepcopy(d)
-    for key, value in d_copy.items():
-        # it could be a list of data or documents or strings
-        if isinstance(value, list):
-            for i, item in enumerate(value):
-                if isinstance(item, Message):
-                    d_copy[key][i] = item.text
-                elif isinstance(item, Data):
-                    d_copy[key][i] = data_to_string(item)
-                elif isinstance(item, Document):
-                    d_copy[key][i] = document_to_string(item)
-        elif isinstance(value, Message):
-            d_copy[key] = value.text
-        elif isinstance(value, Data):
-            d_copy[key] = data_to_string(value)
-        elif isinstance(value, Document):
-            d_copy[key] = document_to_string(value)
-    return d_copy
-
-
-def document_to_string(document: Document) -> str:
-    """Convert a document to a string.
-
-    Args:
-        document (Document): The document to convert.
-
-    Returns:
-        str: The document as a string.
-    """
-    return document.page_content

langflow/base/textsplitters/model.py

@@ -1,28 +0,0 @@
-from abc import abstractmethod
-
-from langchain_core.documents import BaseDocumentTransformer
-from langchain_text_splitters import TextSplitter
-
-from langflow.base.document_transformers.model import LCDocumentTransformerComponent
-
-
-class LCTextSplitterComponent(LCDocumentTransformerComponent):
-    trace_type = "text_splitter"
-
-    def _validate_outputs(self) -> None:
-        required_output_methods = ["text_splitter"]
-        output_names = [output.name for output in self.outputs]
-        for method_name in required_output_methods:
-            if method_name not in output_names:
-                msg = f"Output with name '{method_name}' must be defined."
-                raise ValueError(msg)
-            if not hasattr(self, method_name):
-                msg = f"Method '{method_name}' must be defined."
-                raise ValueError(msg)
-
-    def build_document_transformer(self) -> BaseDocumentTransformer:
-        return self.build_text_splitter()
-
-    @abstractmethod
-    def build_text_splitter(self) -> TextSplitter:
-        """Build the text splitter."""

langflow/base/tools/base.py

@@ -1,26 +0,0 @@
-from langflow.field_typing import Tool
-
-
-def build_status_from_tool(tool: Tool):
-    """Builds a status string representation of a tool.
-
-    Args:
-        tool (Tool): The tool object to build the status for.
-
-    Returns:
-        str: The status string representation of the tool, including its name, description, arguments (if any),
-            and args_schema (if any).
-    """
-    description_repr = repr(tool.description).strip("'")
-    args_str = "\n".join(
-        [
-            f"- {arg_name}: {arg_data['description']}"
-            for arg_name, arg_data in tool.args.items()
-            if "description" in arg_data
-        ]
-    )
-    # Include args_schema information
-    args_schema_str = repr(tool.args_schema) if tool.args_schema else "None"
-    status = f"Name: {tool.name}\nDescription: {description_repr}"
-    status += f"\nArgs Schema: {args_schema_str}"
-    return status + (f"\nArguments:\n{args_str}" if args_str else "")

langflow/base/tools/component_tool.py

@@ -1,324 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import re
-from typing import TYPE_CHECKING, Literal
-
-import pandas as pd
-from langchain_core.tools import BaseTool, ToolException
-from langchain_core.tools.structured import StructuredTool
-
-from langflow.base.tools.constants import TOOL_OUTPUT_NAME
-from langflow.io.schema import create_input_schema, create_input_schema_from_dict
-from langflow.schema.data import Data
-from langflow.schema.message import Message
-from langflow.serialization.serialization import serialize
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from langchain_core.callbacks import Callbacks
-
-    from langflow.custom.custom_component.component import Component
-    from langflow.events.event_manager import EventManager
-    from langflow.inputs.inputs import InputTypes
-    from langflow.io import Output
-    from langflow.schema.content_block import ContentBlock
-    from langflow.schema.dotdict import dotdict
-
-TOOL_TYPES_SET = {"Tool", "BaseTool", "StructuredTool"}
-
-
-def _get_input_type(input_: InputTypes):
-    if input_.input_types:
-        if len(input_.input_types) == 1:
-            return input_.input_types[0]
-        return " | ".join(input_.input_types)
-    return input_.field_type
-
-
-def build_description(component: Component) -> str:
-    return component.description or ""
-
-
-async def send_message_noop(
-    message: Message,
-    text: str | None = None,  # noqa: ARG001
-    background_color: str | None = None,  # noqa: ARG001
-    text_color: str | None = None,  # noqa: ARG001
-    icon: str | None = None,  # noqa: ARG001
-    content_blocks: list[ContentBlock] | None = None,  # noqa: ARG001
-    format_type: Literal["default", "error", "warning", "info"] = "default",  # noqa: ARG001
-    id_: str | None = None,  # noqa: ARG001
-    *,
-    allow_markdown: bool = True,  # noqa: ARG001
-) -> Message:
-    """No-op implementation of send_message."""
-    return message
-
-
-def patch_components_send_message(component: Component):
-    old_send_message = component.send_message
-    component.send_message = send_message_noop  # type: ignore[method-assign, assignment]
-    return old_send_message
-
-
-def _patch_send_message_decorator(component, func):
-    """Decorator to patch the send_message method of a component.
-
-    This is useful when we want to use a component as a tool, but we don't want to
-    send any messages to the UI. With this only the Component calling the tool
-    will send messages to the UI.
-    """
-
-    async def async_wrapper(*args, **kwargs):
-        original_send_message = component.send_message
-        component.send_message = send_message_noop
-        try:
-            return await func(*args, **kwargs)
-        finally:
-            component.send_message = original_send_message
-
-    def sync_wrapper(*args, **kwargs):
-        original_send_message = component.send_message
-        component.send_message = send_message_noop
-        try:
-            return func(*args, **kwargs)
-        finally:
-            component.send_message = original_send_message
-
-    return async_wrapper if asyncio.iscoroutinefunction(func) else sync_wrapper
-
-
-def _build_output_function(component: Component, output_method: Callable, event_manager: EventManager | None = None):
-    def output_function(*args, **kwargs):
-        try:
-            if event_manager:
-                event_manager.on_build_start(data={"id": component._id})
-            component.set(*args, **kwargs)
-            result = output_method()
-            if event_manager:
-                event_manager.on_build_end(data={"id": component._id})
-        except Exception as e:
-            raise ToolException(e) from e
-
-        if isinstance(result, Message):
-            return result.get_text()
-        if isinstance(result, Data):
-            return result.data
-        # removing the model_dump() call here because it is not serializable
-        return serialize(result)
-
-    return _patch_send_message_decorator(component, output_function)
-
-
-def _build_output_async_function(
-    component: Component, output_method: Callable, event_manager: EventManager | None = None
-):
-    async def output_function(*args, **kwargs):
-        try:
-            if event_manager:
-                await asyncio.to_thread(event_manager.on_build_start, data={"id": component._id})
-            component.set(*args, **kwargs)
-            result = await output_method()
-            if event_manager:
-                await asyncio.to_thread(event_manager.on_build_end, data={"id": component._id})
-        except Exception as e:
-            raise ToolException(e) from e
-        if isinstance(result, Message):
-            return result.get_text()
-        if isinstance(result, Data):
-            return result.data
-        # removing the model_dump() call here because it is not serializable
-        return serialize(result)
-
-    return _patch_send_message_decorator(component, output_function)
-
-
-def _format_tool_name(name: str):
-    # format to '^[a-zA-Z0-9_-]+$'."
-    # to do that we must remove all non-alphanumeric characters
-
-    return re.sub(r"[^a-zA-Z0-9_-]", "-", name)
-
-
-def _add_commands_to_tool_description(tool_description: str, commands: str):
-    return f"very_time you see one of those commands {commands} run the tool. tool description is {tool_description}"
-
-
-class ComponentToolkit:
-    def __init__(self, component: Component, metadata: pd.DataFrame | None = None):
-        self.component = component
-        self.metadata = metadata
-
-    def _should_skip_output(self, output: Output) -> bool:
-        """Determines if an output should be skipped when creating tools.
-
-        Args:
-            output (Output): The output to check.
-
-        Returns:
-            bool: True if the output should be skipped, False otherwise.
-
-        The output will be skipped if:
-        - tool_mode is False (output is not meant to be used as a tool)
-        - output name matches TOOL_OUTPUT_NAME
-        - output types contain any of the tool types in TOOL_TYPES_SET
-        """
-        return not output.tool_mode or (
-            output.name == TOOL_OUTPUT_NAME or any(tool_type in output.types for tool_type in TOOL_TYPES_SET)
-        )
-
-    def get_tools(
-        self,
-        tool_name: str | None = None,
-        tool_description: str | None = None,
-        callbacks: Callbacks | None = None,
-        flow_mode_inputs: list[dotdict] | None = None,
-    ) -> list[BaseTool]:
-        tools = []
-        for output in self.component.outputs:
-            if self._should_skip_output(output):
-                continue
-
-            if not output.method:
-                msg = f"Output {output.name} does not have a method defined"
-                raise ValueError(msg)
-
-            output_method: Callable = getattr(self.component, output.method)
-            args_schema = None
-            tool_mode_inputs = [_input for _input in self.component.inputs if getattr(_input, "tool_mode", False)]
-            if flow_mode_inputs:
-                args_schema = create_input_schema_from_dict(
-                    inputs=flow_mode_inputs,
-                    param_key="flow_tweak_data",
-                )
-            elif tool_mode_inputs:
-                args_schema = create_input_schema(tool_mode_inputs)
-            elif output.required_inputs:
-                inputs = [
-                    self.component._inputs[input_name]
-                    for input_name in output.required_inputs
-                    if getattr(self.component, input_name) is None
-                ]
-                # If any of the required inputs are not in tool mode, this means
-                # that when the tool is called it will raise an error.
-                # so we should raise an error here.
-                # TODO: This logic might need to be improved, example if the required is an api key.
-                if not all(getattr(_input, "tool_mode", False) for _input in inputs):
-                    non_tool_mode_inputs = [
-                        input_.name
-                        for input_ in inputs
-                        if not getattr(input_, "tool_mode", False) and input_.name is not None
-                    ]
-                    non_tool_mode_inputs_str = ", ".join(non_tool_mode_inputs)
-                    msg = (
-                        f"Output '{output.name}' requires inputs that are not in tool mode. "
-                        f"The following inputs are not in tool mode: {non_tool_mode_inputs_str}. "
-                        "Please ensure all required inputs are set to tool mode."
-                    )
-                    raise ValueError(msg)
-                args_schema = create_input_schema(inputs)
-
-            else:
-                args_schema = create_input_schema(self.component.inputs)
-
-            name = f"{output.method}".strip(".")
-            formatted_name = _format_tool_name(name)
-            event_manager = self.component._event_manager
-            if asyncio.iscoroutinefunction(output_method):
-                tools.append(
-                    StructuredTool(
-                        name=formatted_name,
-                        description=build_description(self.component),
-                        coroutine=_build_output_async_function(self.component, output_method, event_manager),
-                        args_schema=args_schema,
-                        handle_tool_error=True,
-                        callbacks=callbacks,
-                        tags=[formatted_name],
-                        metadata={
-                            "display_name": formatted_name,
-                            "display_description": build_description(self.component),
-                        },
-                    )
-                )
-            else:
-                tools.append(
-                    StructuredTool(
-                        name=formatted_name,
-                        description=build_description(self.component),
-                        func=_build_output_function(self.component, output_method, event_manager),
-                        args_schema=args_schema,
-                        handle_tool_error=True,
-                        callbacks=callbacks,
-                        tags=[formatted_name],
-                        metadata={
-                            "display_name": formatted_name,
-                            "display_description": build_description(self.component),
-                        },
-                    )
-                )
-        if len(tools) == 1 and (tool_name or tool_description):
-            tool = tools[0]
-            tool.name = _format_tool_name(str(tool_name)) or tool.name
-            tool.description = tool_description or tool.description
-            tool.tags = [tool.name]
-        elif flow_mode_inputs and (tool_name or tool_description):
-            for tool in tools:
-                tool.name = _format_tool_name(str(tool_name) + "_" + str(tool.name)) or tool.name
-                tool.description = (
-                    str(tool_description) + " Output details: " + str(tool.description)
-                ) or tool.description
-                tool.tags = [tool.name]
-        elif tool_name or tool_description:
-            msg = (
-                "When passing a tool name or description, there must be only one tool, "
-                f"but {len(tools)} tools were found."
-            )
-            raise ValueError(msg)
-        return tools
-
-    def get_tools_metadata_dictionary(self) -> dict:
-        if isinstance(self.metadata, pd.DataFrame):
-            try:
-                return {
-                    record["tags"][0]: record
-                    for record in self.metadata.to_dict(orient="records")
-                    if record.get("tags")
-                }
-            except (KeyError, IndexError) as e:
-                msg = "Error processing metadata records: " + str(e)
-                raise ValueError(msg) from e
-        return {}
-
-    def update_tools_metadata(
-        self,
-        tools: list[BaseTool | StructuredTool],
-    ) -> list[BaseTool]:
-        # update the tool_name and description according to the name and secriotion mentioned in the list
-        if isinstance(self.metadata, pd.DataFrame):
-            metadata_dict = self.get_tools_metadata_dictionary()
-            filtered_tools = []
-            for tool in tools:
-                if isinstance(tool, StructuredTool | BaseTool) and tool.tags:
-                    try:
-                        tag = tool.tags[0]
-                    except IndexError:
-                        msg = "Tool tags cannot be empty."
-                        raise ValueError(msg) from None
-                    if tag in metadata_dict:
-                        tool_metadata = metadata_dict[tag]
-                        # Only include tools with status=True
-                        if tool_metadata.get("status", True):
-                            tool.name = tool_metadata.get("name", tool.name)
-                            tool.description = tool_metadata.get("description", tool.description)
-                            if tool_metadata.get("commands"):
-                                tool.description = _add_commands_to_tool_description(
-                                    tool.description, tool_metadata.get("commands")
-                                )
-                            filtered_tools.append(tool)
-                else:
-                    msg = f"Expected a StructuredTool or BaseTool, got {type(tool)}"
-                    raise TypeError(msg)
-            return filtered_tools
-        return tools

langflow/base/tools/constants.py

@@ -1,49 +0,0 @@
-from langflow.schema.table import EditMode
-
-TOOL_OUTPUT_NAME = "component_as_tool"
-TOOL_OUTPUT_DISPLAY_NAME = "Toolset"
-TOOLS_METADATA_INPUT_NAME = "tools_metadata"
-TOOL_TABLE_SCHEMA = [
-    {
-        "name": "name",
-        "display_name": "Tool Name",
-        "type": "str",
-        "description": "Specify the name of the tool.",
-        "sortable": False,
-        "filterable": False,
-        "edit_mode": EditMode.INLINE,
-        "hidden": False,
-    },
-    {
-        "name": "description",
-        "display_name": "Tool Description",
-        "type": "str",
-        "description": "Describe the purpose of the tool.",
-        "sortable": False,
-        "filterable": False,
-        "edit_mode": EditMode.POPOVER,
-        "hidden": False,
-    },
-    {
-        "name": "tags",
-        "display_name": "Tool Identifiers",
-        "type": "str",
-        "description": ("The default identifiers for the tools and cannot be changed."),
-        "disable_edit": True,
-        "sortable": False,
-        "filterable": False,
-        "edit_mode": EditMode.INLINE,
-        "hidden": True,
-    },
-    {
-        "name": "status",
-        "display_name": "Enable",
-        "type": "boolean",
-        "description": "Indicates whether the tool is currently active. Set to True to activate this tool.",
-        "default": True,
-    },
-]
-
-TOOLS_METADATA_INFO = "Modify tool names and descriptions to help agents understand when to use each tool."
-
-TOOL_UPDATE_CONSTANTS = ["tool_mode", "tool_actions", TOOLS_METADATA_INPUT_NAME, "flow_name_selected"]