⚡️ Speed up function `set_multiple_field_display` by 24% in PR #7741 (`mcp-server-backend`)

[codeflash-ai[bot]]

⚡️ This pull request contains optimizations for PR #7741

If you approve this dependent PR, these changes will be merged into the original PR branch mcp-server-backend.

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

---

📄 24% (0.24x) speedup for set_multiple_field_display in src/backend/base/langflow/utils/component_utils.py

⏱️ Runtime : 1.14 millisecond → 923 microseconds (best of 73 runs)

📝 Explanation and details

To optimize the given code for better performance, I will make the following changes.

1. Using dictionary methods directly instead of multiple nested checks.
2. Minimize repetitive function calls by combining processing steps in loops.
3. Comments will be preserved as they are mostly on function-level, and more details will be added if necessary.

Here is the rewritten optimized code.

The optimizations include.

1. Eliminating redundant dictionary accesses: Use .get() method directly to minimize redundant dictionary look-ups.
2. Removing unnecessary function calls in loops: Inline the logic of set_field_display within set_multiple_field_display to avoid repeatedly calling the function.
3. Type-specific improvements: Use if fields: and if field_list: to check if these are provided instead of verbose is not None.

These changes should result in improved performance by reducing function call overhead and minimizing the number of dictionary accesses.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

import pytest  # used for our unit tests
# function to test
from langflow.schema.dotdict import dotdict
from langflow.utils.component_utils import set_multiple_field_display


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()
from langflow.utils.component_utils import set_multiple_field_display

# unit tests

# Basic Functionality
def test_single_field_visibility_true():
    build_config = dotdict({'field1': {'show': False}})
    fields = {'field1': True}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

def test_multiple_fields_mixed_visibility():
    build_config = dotdict({'field1': {'show': False}, 'field2': {'show': True}, 'field3': {'show': False}})
    fields = {'field1': True, 'field2': False, 'field3': True}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

# Field List with Common Visibility
def test_single_field_list_visibility_true():
    build_config = dotdict({'field1': {'show': False}})
    field_list = ['field1']
    codeflash_output = set_multiple_field_display(build_config, field_list=field_list, is_visible=True); result = codeflash_output

def test_multiple_field_list_visibility_false():
    build_config = dotdict({'field1': {'show': True}, 'field2': {'show': True}, 'field3': {'show': True}})
    field_list = ['field1', 'field2', 'field3']
    codeflash_output = set_multiple_field_display(build_config, field_list=field_list, is_visible=False); result = codeflash_output

# Edge Cases
def test_empty_fields_dict():
    build_config = dotdict({'field1': {'show': False}})
    fields = {}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

def test_empty_field_list():
    build_config = dotdict({'field1': {'show': False}})
    field_list = []
    codeflash_output = set_multiple_field_display(build_config, field_list=field_list, is_visible=True); result = codeflash_output

def test_field_not_present_in_build_config():
    build_config = dotdict({'field1': {'show': False}})
    fields = {'non_existent_field': True}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

# Nested dotdict Structures
def test_nested_field_visibility():
    build_config = dotdict({'field1': {'show': False, 'nested_field': {'show': True}}})
    fields = {'field1.nested_field': False}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

# Invalid Inputs

def test_large_number_of_fields():
    build_config = dotdict({f'field{i}': {'show': False} for i in range(1000)})
    fields = {f'field{i}': True for i in range(1000)}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output
    for i in range(1000):
        pass

def test_large_field_list():
    build_config = dotdict({f'field{i}': {'show': False} for i in range(1000)})
    field_list = [f'field{i}' for i in range(1000)]
    codeflash_output = set_multiple_field_display(build_config, field_list=field_list, is_visible=True); result = codeflash_output
    for i in range(1000):
        pass

# Complex Configurations
def test_mixed_nested_and_non_nested_fields():
    build_config = dotdict({'field1': {'show': True}, 'field2': {'show': False, 'nested_field': {'show': True}}})
    fields = {'field1': False, 'field2.nested_field': False}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

def test_multiple_nested_levels():
    build_config = dotdict({'field1': {'show': True, 'nested_field': {'show': True, 'deep_nested_field': {'show': True}}}})
    fields = {'field1.nested_field.deep_nested_field': False}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

# Rare or Unexpected Edge Cases

# Fields with Special Characters
def test_field_name_with_spaces():
    build_config = dotdict({'field with spaces': {'show': False}})
    fields = {'field with spaces': True}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

def test_field_name_with_special_characters():
    build_config = dotdict({'field@name!': {'show': True}})
    fields = {'field@name!': False}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

# Fields with Empty Strings or None
def test_empty_string_as_field_name():
    build_config = dotdict({'': {'show': False}})
    fields = {'': True}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

def test_none_as_field_name():
    build_config = dotdict({None: {'show': True}})
    fields = {None: False}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

# Fields with Non-Boolean Visibility Values


def test_multiple_levels_of_nesting():
    build_config = dotdict({'field1': {'nested1': {'nested2': {'nested3': {'show': True}}}}})
    fields = {'field1.nested1.nested2.nested3': False}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

# Circular References in dotdict
def test_self_referencing_field():
    build_config = dotdict({'field1': {'show': True}})
    build_config['field1']['self'] = build_config['field1']
    fields = {'field1.self.show': False}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

# Fields with Mixed Data Types
def test_field_with_list_value():
    build_config = dotdict({'field1': {'show': True, 'list_field': [1, 2, 3]}})
    fields = {'field1.list_field': False}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

def test_field_with_integer_value():
    build_config = dotdict({'field1': {'show': True, 'int_field': 123}})
    fields = {'field1.int_field': False}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output

# Conflicting Inputs
def test_conflicting_inputs():
    build_config = dotdict({'field1': {'show': False}, 'field2': {'show': True}})
    fields = {'field1': True}
    field_list = ['field2']
    codeflash_output = set_multiple_field_display(build_config, fields=fields, field_list=field_list, is_visible=False); result = codeflash_output
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from langflow.utils.component_utils import set_multiple_field_display


# function to test
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()
from langflow.utils.component_utils import set_multiple_field_display

# unit tests

# Basic Functionality

def test_single_field_true():
    build_config = dotdict({"field1": {"show": False}})
    codeflash_output = set_multiple_field_display(build_config, fields={"field1": True}); result = codeflash_output

def test_single_field_false():
    build_config = dotdict({"field1": {"show": True}})
    codeflash_output = set_multiple_field_display(build_config, fields={"field1": False}); result = codeflash_output

def test_multiple_fields():
    build_config = dotdict({"field1": {"show": False}, "field2": {"show": True}})
    codeflash_output = set_multiple_field_display(build_config, fields={"field1": True, "field2": False}); result = codeflash_output

# Field List with Common Visibility

def test_field_list_single_true():
    build_config = dotdict({"field1": {"show": False}})
    codeflash_output = set_multiple_field_display(build_config, field_list=["field1"], is_visible=True); result = codeflash_output

def test_field_list_single_false():
    build_config = dotdict({"field1": {"show": True}})
    codeflash_output = set_multiple_field_display(build_config, field_list=["field1"], is_visible=False); result = codeflash_output

def test_field_list_multiple_true():
    build_config = dotdict({"field1": {"show": False}, "field2": {"show": False}})
    codeflash_output = set_multiple_field_display(build_config, field_list=["field1", "field2"], is_visible=True); result = codeflash_output

def test_field_list_multiple_false():
    build_config = dotdict({"field1": {"show": True}, "field2": {"show": True}})
    codeflash_output = set_multiple_field_display(build_config, field_list=["field1", "field2"], is_visible=False); result = codeflash_output

# Mixed Inputs

def test_fields_and_field_list():
    build_config = dotdict({"field1": {"show": False}, "field2": {"show": False}})
    codeflash_output = set_multiple_field_display(build_config, fields={"field1": True}, field_list=["field2"], is_visible=True); result = codeflash_output

# Edge Cases

def test_empty_inputs():
    build_config = dotdict({"field1": {"show": False}})
    codeflash_output = set_multiple_field_display(build_config); result = codeflash_output

def test_empty_fields():
    build_config = dotdict({"field1": {"show": False}})
    codeflash_output = set_multiple_field_display(build_config, fields={}); result = codeflash_output

def test_empty_field_list():
    build_config = dotdict({"field1": {"show": False}})
    codeflash_output = set_multiple_field_display(build_config, field_list=[]); result = codeflash_output

def test_non_existent_field_in_fields():
    build_config = dotdict({"field1": {"show": False}})
    codeflash_output = set_multiple_field_display(build_config, fields={"non_existent_field": True}); result = codeflash_output

def test_non_existent_field_in_field_list():
    build_config = dotdict({"field1": {"show": False}})
    codeflash_output = set_multiple_field_display(build_config, field_list=["non_existent_field"], is_visible=True); result = codeflash_output




def test_nested_dotdict():
    build_config = dotdict({"nested": {"field1": {"show": False}}})
    codeflash_output = set_multiple_field_display(build_config, fields={"nested.field1": True}); result = codeflash_output

# Large Scale Test Cases

def test_large_number_of_fields():
    build_config = dotdict({f"field{i}": {"show": False} for i in range(1000)})
    fields = {f"field{i}": True for i in range(1000)}
    codeflash_output = set_multiple_field_display(build_config, fields=fields); result = codeflash_output
    for i in range(1000):
        pass

def test_large_number_of_field_list():
    build_config = dotdict({f"field{i}": {"show": False} for i in range(1000)})
    field_list = [f"field{i}" for i in range(1000)]
    codeflash_output = set_multiple_field_display(build_config, field_list=field_list, is_visible=True); result = codeflash_output
    for i in range(1000):
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr7741-2025-04-24T07.26.23 and push.