⚡️ Speed up method ComponentToolkit.get_tools by 11% in PR #6028 (PlaygroundPage)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #6028

If you approve this dependent PR, these changes will be merged into the original PR branch PlaygroundPage.

This PR will be automatically closed if the original PR is merged.

---

📄 11% (0.11x) speedup for ComponentToolkit.get_tools in src/backend/base/langflow/base/tools/component_tool.py

⏱️ Runtime : 3.13 milliseconds → 2.82 milliseconds (best of 29 runs)

📝 Explanation and details

Optimizing this Python program involves addressing inefficiencies in its structure and usage of resources. We'll focus on minimizing redundant operations, improving loop structures, avoiding unnecessary type casting, and enhancing asynchronous function handling. Here's the optimized version.

Optimization Summary.

1. Reduce Redundant Logic: Combined checks and structured the flow for clarity and reduced redundant logic.
2. Use Efficient String Handling: Improved string formatting to avoid overhead and removed unnecessary condition checks.
3. Improved Error Handling: Simplified error handling and message construction.
4. Asynchronous Handling: Improved the use of asyncio.to_thread for potentially blocking operations.
5. Simplified Model Creation: Directly used Pydantic model creation without redundant intermediate steps.

These changes aim to make the program faster and more maintainable without altering its functionality.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 7 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	undefined

🌀 Generated Regression Tests Details

from __future__ import annotations

import asyncio
import re
from collections.abc import Callable
from typing import Literal
from unittest.mock import MagicMock

import pandas as pd
# Import necessary modules
# imports
import pytest  # used for our unit tests
from langchain_core.callbacks import Callbacks
from langchain_core.tools import BaseTool, ToolException
from langchain_core.tools.structured import StructuredTool
from langflow.base.tools.component_tool import ComponentToolkit
from langflow.base.tools.constants import TOOL_OUTPUT_NAME
from langflow.custom.custom_component.component import Component
from langflow.events.event_manager import EventManager
from langflow.inputs.inputs import FieldTypes, InputTypes
from langflow.io import Output
from langflow.io.schema import (create_input_schema,
                                create_input_schema_from_dict)
from langflow.schema.data import Data
from langflow.schema.dotdict import dotdict
from langflow.schema.message import Message
from loguru import logger
from pydantic import BaseModel, Field, create_model


class dotdict(dict):  # noqa: N801
    """dotdict allows accessing dictionary elements using dot notation (e.g., dict.key instead of dict['key']).

    It automatically converts nested dictionaries into dotdict instances, enabling dot notation on them as well.

    Note:
        - Only keys that are valid attribute names (e.g., strings that could be variable names) are accessible via dot
          notation.
        - Keys which are not valid Python attribute names or collide with the dict method names (like 'items', 'keys')
          should be accessed using the traditional dict['key'] notation.
    """

    def __getattr__(self, attr):
        """Override dot access to behave like dictionary lookup. Automatically convert nested dicts to dotdicts.

        Args:
            attr (str): Attribute to access.

        Returns:
            The value associated with 'attr' in the dictionary, converted to dotdict if it is a dict.

        Raises:
            AttributeError: If the attribute is not found in the dictionary.
        """
        try:
            value = self[attr]
            if isinstance(value, dict) and not isinstance(value, dotdict):
                value = dotdict(value)
                self[attr] = value  # Update self to nest dotdict for future accesses
        except KeyError as e:
            msg = f"'dotdict' object has no attribute '{attr}'"
            raise AttributeError(msg) from e
        else:
            return value

    def __setattr__(self, key, value) -> None:
        """Override attribute setting to work as dictionary item assignment.

        Args:
            key (str): The key under which to store the value.
            value: The value to store in the dictionary.
        """
        if isinstance(value, dict) and not isinstance(value, dotdict):
            value = dotdict(value)
        self[key] = value

    def __delattr__(self, key) -> None:
        """Override attribute deletion to work as dictionary item deletion.

        Args:
            key (str): The key of the item to delete from the dictionary.

        Raises:
            AttributeError: If the key is not found in the dictionary.
        """
        try:
            del self[key]
        except KeyError as e:
            msg = f"'dotdict' object has no attribute '{key}'"
            raise AttributeError(msg) from e

    def __missing__(self, key):
        """Handle missing keys by returning an empty dotdict. This allows chaining access without raising KeyError.

        Args:
            key: The missing key.

        Returns:
            An empty dotdict instance for the given missing key.
        """
        return dotdict()

# unit tests


# Define mock classes for testing
class MockComponent:
    def __init__(self, outputs=None, inputs=None, event_manager=None):
        self.outputs = outputs or []
        self.inputs = inputs or []
        self._inputs = {input_.name: input_ for input_ in self.inputs}
        self._event_manager = event_manager

class MockOutput:
    def __init__(self, name, method=None, tool_mode=True, required_inputs=None):
        self.name = name
        self.method = method
        self.tool_mode = tool_mode
        self.required_inputs = required_inputs or []

class MockInput:
    def __init__(self, name, field_type="str", tool_mode=True, options=None, is_list=False, required=True):
        self.name = name
        self.field_type = field_type
        self.tool_mode = tool_mode
        self.options = options or []
        self.is_list = is_list
        self.required = required

# Test cases



def test_invalid_output_method():
    # Missing or invalid inputs: invalid output method
    component = MockComponent(outputs=[MockOutput(name="output1", method="invalid_method")])
    toolkit = ComponentToolkit(component)
    with pytest.raises(AttributeError):
        toolkit.get_tools()

def test_output_not_in_tool_mode():
    # Tool mode conditions: output not in tool mode
    component = MockComponent(outputs=[MockOutput(name="output1", method="method1", tool_mode=False)])
    toolkit = ComponentToolkit(component)
    codeflash_output = toolkit.get_tools()


def test_inputs_with_options():
    # Input schema variations: inputs with options
    component = MockComponent(inputs=[MockInput(name="input1", options=["option1", "option2"])])
    toolkit = ComponentToolkit(component)
    codeflash_output = toolkit.get_tools()

def test_list_inputs():
    # Input schema variations: list inputs
    component = MockComponent(inputs=[MockInput(name="input1", is_list=True)])
    toolkit = ComponentToolkit(component)
    codeflash_output = toolkit.get_tools()

def test_optional_inputs():
    # Input schema variations: optional inputs
    component = MockComponent(inputs=[MockInput(name="input1", required=False)])
    toolkit = ComponentToolkit(component)
    codeflash_output = toolkit.get_tools()





from __future__ import annotations

import asyncio
import re
from collections.abc import Callable
from typing import Literal
from unittest.mock import MagicMock

import pandas as pd
# imports
import pytest  # used for our unit tests
from langchain_core.callbacks import Callbacks
from langchain_core.tools import BaseTool, ToolException
from langchain_core.tools.structured import StructuredTool
from langflow.base.tools.component_tool import ComponentToolkit
from langflow.base.tools.constants import TOOL_OUTPUT_NAME
from langflow.custom.custom_component.component import Component
from langflow.events.event_manager import EventManager
from langflow.inputs.inputs import FieldTypes, InputTypes
from langflow.io import Output
from langflow.io.schema import (create_input_schema,
                                create_input_schema_from_dict)
from langflow.schema.data import Data
from langflow.schema.dotdict import dotdict
from langflow.schema.message import Message
from loguru import logger
from pydantic import BaseModel, Field, create_model


class dotdict(dict):  # noqa: N801
    """dotdict allows accessing dictionary elements using dot notation (e.g., dict.key instead of dict['key']).

    It automatically converts nested dictionaries into dotdict instances, enabling dot notation on them as well.

    Note:
        - Only keys that are valid attribute names (e.g., strings that could be variable names) are accessible via dot
          notation.
        - Keys which are not valid Python attribute names or collide with the dict method names (like 'items', 'keys')
          should be accessed using the traditional dict['key'] notation.
    """

    def __getattr__(self, attr):
        """Override dot access to behave like dictionary lookup. Automatically convert nested dicts to dotdicts.

        Args:
            attr (str): Attribute to access.

        Returns:
            The value associated with 'attr' in the dictionary, converted to dotdict if it is a dict.

        Raises:
            AttributeError: If the attribute is not found in the dictionary.
        """
        try:
            value = self[attr]
            if isinstance(value, dict) and not isinstance(value, dotdict):
                value = dotdict(value)
                self[attr] = value  # Update self to nest dotdict for future accesses
        except KeyError as e:
            msg = f"'dotdict' object has no attribute '{attr}'"
            raise AttributeError(msg) from e
        else:
            return value

    def __setattr__(self, key, value) -> None:
        """Override attribute setting to work as dictionary item assignment.

        Args:
            key (str): The key under which to store the value.
            value: The value to store in the dictionary.
        """
        if isinstance(value, dict) and not isinstance(value, dotdict):
            value = dotdict(value)
        self[key] = value

    def __delattr__(self, key) -> None:
        """Override attribute deletion to work as dictionary item deletion.

        Args:
            key (str): The key of the item to delete from the dictionary.

        Raises:
            AttributeError: If the key is not found in the dictionary.
        """
        try:
            del self[key]
        except KeyError as e:
            msg = f"'dotdict' object has no attribute '{key}'"
            raise AttributeError(msg) from e

    def __missing__(self, key):
        """Handle missing keys by returning an empty dotdict. This allows chaining access without raising KeyError.

        Args:
            key: The missing key.

        Returns:
            An empty dotdict instance for the given missing key.
        """
        return dotdict()

# unit tests

@pytest.fixture
def mock_component():
    """Fixture to create a mock component with default attributes."""
    component = MagicMock(spec=Component)
    component.outputs = []
    component.inputs = []
    component._inputs = {}
    component._event_manager = None
    component.description = "Mock Component"
    return component

def test_no_outputs(mock_component):
    """Test case for a component with no outputs."""
    toolkit = ComponentToolkit(component=mock_component)
    codeflash_output = toolkit.get_tools()







def test_tool_mode_inputs(mock_component):
    """Test case for a component with tool mode inputs."""
    mock_output = MagicMock(spec=Output)
    mock_output.method = "output_method"
    mock_output.required_inputs = ["input1"]
    mock_output.tool_mode = True
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.