⚡️ Speed up function _expand_edge by 13% in PR #10785 (feat/no-code-pre-built-component)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #10785

If you approve this dependent PR, these changes will be merged into the original PR branch feat/no-code-pre-built-component.

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

---

📄 13% (0.13x) speedup for _expand_edge in src/backend/base/langflow/processing/expand_flow.py

⏱️ Runtime : 2.10 milliseconds → 1.85 milliseconds (best of 103 runs)

📝 Explanation and details

The optimized code achieves a 13% speedup through several targeted micro-optimizations that reduce function call overhead and improve attribute access patterns:

Key Optimizations Applied:

1. Import hoisting: Moved escape_json_dump import to module scope, eliminating 450 repeated import lookups (94.7% of _encode_handle time in profiler).

2. Attribute access caching: Stored compact_edge.source, compact_edge.target, etc. in local variables (src, tgt, src_out, tgt_in) to avoid repeated attribute lookups throughout the function.

3. Generator expression to for-loop: Replaced next((o for o in source_outputs if o.get("name") == compact_edge.source_output), None) with an explicit for-loop with early break. This eliminates generator overhead and function call overhead from next().

4. Type checking optimization: Changed isinstance(target_field, dict) to type(target_field) is dict, which is faster for exact type matches in CPython.

5. Inlined dictionary creation: Replaced helper function calls _build_source_handle_data() and _build_target_handle_data() with direct dictionary construction, eliminating function call overhead (20.8% of total time).

6. Direct function calls: Replaced _encode_handle() calls with direct escape_json_dump() calls, removing an unnecessary function wrapper layer.

7. String concatenation: Used explicit string concatenation instead of f-strings for edge_id construction, which is marginally faster for multiple concatenations.

Performance Impact:
The optimizations are particularly effective for the test cases with large numbers of nodes and edges (like test_large_scale_multiple_edges with 100 edges), where the cumulative effect of eliminating function call overhead and repeated attribute access becomes significant. For basic test cases, the improvements are more modest but still measurable due to the high-frequency nature of import and attribute access operations.

These optimizations maintain identical behavior while reducing execution time from 2.10ms to 1.85ms, making the function more efficient for flow processing workloads that may call this function repeatedly.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# Patch the import in _encode_handle to use our stub
import sys
import types
from typing import Any

# imports
import pytest
from langflow.processing.expand_flow import _expand_edge


# --- CompactEdge class definition for tests ---
class CompactEdge:
    def __init__(self, source, source_output, target, target_input):
        self.source = source
        self.source_output = source_output
        self.target = target
        self.target_input = target_input
from langflow.processing.expand_flow import _expand_edge

# --- Unit tests ---

# Basic Test Cases

def test_basic_expansion_with_outputs_and_types():
    # Test normal expansion from compact edge with outputs and types
    compact_edge = CompactEdge("nodeA", "outA", "nodeB", "inB")
    expanded_nodes = {
        "nodeA": {
            "data": {
                "type": "ComponentA",
                "node": {
                    "outputs": [
                        {"name": "outA", "types": ["str", "int"]},
                        {"name": "outB", "types": ["float"]}
                    ],
                    "base_classes": ["BaseTypeA"]
                }
            }
        },
        "nodeB": {
            "data": {
                "type": "ComponentB",
                "node": {
                    "template": {
                        "inB": {"input_types": ["str"], "type": "str"},
                        "other": {"input_types": ["int"], "type": "int"}
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_basic_expansion_with_missing_output_types_uses_base_classes():
    # Test fallback to base_classes if output types missing
    compact_edge = CompactEdge("nodeA", "outX", "nodeB", "inB")
    expanded_nodes = {
        "nodeA": {
            "data": {
                "type": "CompA",
                "node": {
                    "outputs": [
                        {"name": "outA", "types": ["str"]},
                    ],
                    "base_classes": ["FallbackType"]
                }
            }
        },
        "nodeB": {
            "data": {
                "type": "CompB",
                "node": {
                    "template": {
                        "inB": {"input_types": ["int"], "type": "int"},
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_basic_expansion_with_missing_input_types_uses_type():
    # Test fallback to field type if input_types missing
    compact_edge = CompactEdge("nodeA", "outA", "nodeB", "inB")
    expanded_nodes = {
        "nodeA": {
            "data": {
                "type": "CompA",
                "node": {
                    "outputs": [
                        {"name": "outA", "types": ["str"]},
                    ],
                    "base_classes": ["FallbackType"]
                }
            }
        },
        "nodeB": {
            "data": {
                "type": "CompB",
                "node": {
                    "template": {
                        "inB": {"type": "float"},
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output


def test_missing_source_node_raises_valueerror():
    # Test error when source node missing
    compact_edge = CompactEdge("missing", "outA", "nodeB", "inB")
    expanded_nodes = {
        "nodeB": {
            "data": {
                "type": "CompB",
                "node": {
                    "template": {
                        "inB": {"input_types": ["int"], "type": "int"},
                    }
                }
            }
        }
    }
    with pytest.raises(ValueError) as e:
        _expand_edge(compact_edge, expanded_nodes)

def test_missing_target_node_raises_valueerror():
    # Test error when target node missing
    compact_edge = CompactEdge("nodeA", "outA", "missing", "inB")
    expanded_nodes = {
        "nodeA": {
            "data": {
                "type": "CompA",
                "node": {
                    "outputs": [
                        {"name": "outA", "types": ["str"]},
                    ],
                    "base_classes": ["FallbackType"]
                }
            }
        }
    }
    with pytest.raises(ValueError) as e:
        _expand_edge(compact_edge, expanded_nodes)

def test_empty_outputs_and_base_classes():
    # Test case with no outputs and no base_classes (should get empty list)
    compact_edge = CompactEdge("nodeA", "outA", "nodeB", "inB")
    expanded_nodes = {
        "nodeA": {
            "data": {
                "type": "CompA",
                "node": {
                    "outputs": [],
                    "base_classes": []
                }
            }
        },
        "nodeB": {
            "data": {
                "type": "CompB",
                "node": {
                    "template": {
                        "inB": {"input_types": [], "type": "str"},
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_empty_template_and_field():
    # Test case with empty template dict
    compact_edge = CompactEdge("nodeA", "outA", "nodeB", "missingField")
    expanded_nodes = {
        "nodeA": {
            "data": {
                "type": "CompA",
                "node": {
                    "outputs": [
                        {"name": "outA", "types": ["str"]},
                    ],
                    "base_classes": ["FallbackType"]
                }
            }
        },
        "nodeB": {
            "data": {
                "type": "CompB",
                "node": {
                    "template": {}
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_output_types_not_list():
    # Test case where types field is not a list (should fallback to base_classes)
    compact_edge = CompactEdge("nodeA", "outA", "nodeB", "inB")
    expanded_nodes = {
        "nodeA": {
            "data": {
                "type": "CompA",
                "node": {
                    "outputs": [
                        {"name": "outA", "types": None},
                    ],
                    "base_classes": ["FallbackType"]
                }
            }
        },
        "nodeB": {
            "data": {
                "type": "CompB",
                "node": {
                    "template": {
                        "inB": {"input_types": ["int"], "type": "int"},
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_input_types_not_list():
    # Test case where input_types is not a list (should fallback to [type])
    compact_edge = CompactEdge("nodeA", "outA", "nodeB", "inB")
    expanded_nodes = {
        "nodeA": {
            "data": {
                "type": "CompA",
                "node": {
                    "outputs": [
                        {"name": "outA", "types": ["str"]},
                    ],
                    "base_classes": ["FallbackType"]
                }
            }
        },
        "nodeB": {
            "data": {
                "type": "CompB",
                "node": {
                    "template": {
                        "inB": {"input_types": None, "type": "float"},
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

# Large Scale Test Cases

def test_large_number_of_nodes_and_edges():
    # Test performance and correctness with many nodes and edges
    num_nodes = 100
    expanded_nodes = {}
    # Create nodes with unique outputs and templates
    for i in range(num_nodes):
        node_id = f"node{i}"
        expanded_nodes[node_id] = {
            "data": {
                "type": f"Type{i}",
                "node": {
                    "outputs": [
                        {"name": f"out{i}", "types": [f"type{i}"]},
                    ],
                    "base_classes": [f"Base{i}"]
                }
            }
        }
    # Add templates to all nodes
    for i in range(num_nodes):
        expanded_nodes[f"node{i}"]["data"]["node"]["template"] = {
            f"in{i}": {"input_types": [f"type{i}"], "type": f"type{i}"}
        }
    # Create and test edges between consecutive nodes
    for i in range(num_nodes - 1):
        compact_edge = CompactEdge(f"node{i}", f"out{i}", f"node{i+1}", f"in{i+1}")
        codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_large_outputs_and_inputs_lists():
    # Test nodes with large outputs and input_types lists
    outputs = [{"name": f"out{k}", "types": [f"type{k}"]} for k in range(50)]
    input_types = [f"type{k}" for k in range(50)]
    compact_edge = CompactEdge("nodeA", "out25", "nodeB", "inB")
    expanded_nodes = {
        "nodeA": {
            "data": {
                "type": "LargeTypeA",
                "node": {
                    "outputs": outputs,
                    "base_classes": ["BaseA"]
                }
            }
        },
        "nodeB": {
            "data": {
                "type": "LargeTypeB",
                "node": {
                    "template": {
                        "inB": {"input_types": input_types, "type": "str"},
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_large_base_classes_fallback():
    # Test fallback to large base_classes list
    base_classes = [f"Base{k}" for k in range(100)]
    compact_edge = CompactEdge("nodeA", "missing_output", "nodeB", "inB")
    expanded_nodes = {
        "nodeA": {
            "data": {
                "type": "LargeTypeA",
                "node": {
                    "outputs": [],
                    "base_classes": base_classes
                }
            }
        },
        "nodeB": {
            "data": {
                "type": "LargeTypeB",
                "node": {
                    "template": {
                        "inB": {"input_types": ["str"], "type": "str"},
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_large_template_missing_field():
    # Test large template dict where target_input is missing (should fallback to "str")
    template = {f"in{k}": {"input_types": [f"type{k}"], "type": f"type{k}"} for k in range(100)}
    compact_edge = CompactEdge("nodeA", "outA", "nodeB", "missingField")
    expanded_nodes = {
        "nodeA": {
            "data": {
                "type": "TypeA",
                "node": {
                    "outputs": [
                        {"name": "outA", "types": ["str"]},
                    ],
                    "base_classes": ["BaseA"]
                }
            }
        },
        "nodeB": {
            "data": {
                "type": "TypeB",
                "node": {
                    "template": template
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); 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.
#------------------------------------------------
from __future__ import annotations

# Patch the import inside _encode_handle to use our stub
import builtins
import sys
import types
from typing import Any

# imports
import pytest
from langflow.processing.expand_flow import _expand_edge

# --- Minimal stubs for dependencies and CompactEdge ---
# These are required to make the test file self-contained.

class CompactEdge:
    """Minimal stub for CompactEdge used in _expand_edge."""
    def __init__(self, source, source_output, target, target_input):
        self.source = source
        self.source_output = source_output
        self.target = target
        self.target_input = target_input
from langflow.processing.expand_flow import _expand_edge

# --- Unit Tests ---
# Basic, Edge, and Large Scale scenarios

# ----------- BASIC TEST CASES -----------

def test_basic_expansion_with_outputs_and_types():
    """
    Basic: Source node has outputs with types, target node has template with input_types and type.
    """
    compact_edge = CompactEdge("node1", "outA", "node2", "inB")
    expanded_nodes = {
        "node1": {
            "data": {
                "type": "ComponentA",
                "node": {
                    "outputs": [{"name": "outA", "types": ["str", "int"]}],
                    "base_classes": ["BaseA"]
                }
            }
        },
        "node2": {
            "data": {
                "type": "ComponentB",
                "node": {
                    "template": {
                        "inB": {"input_types": ["str"], "type": "str"}
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_basic_expansion_with_missing_output_types_uses_base_classes():
    """
    Basic: Source node output has no types, should fallback to base_classes.
    """
    compact_edge = CompactEdge("node1", "outA", "node2", "inB")
    expanded_nodes = {
        "node1": {
            "data": {
                "type": "TypeX",
                "node": {
                    "outputs": [{"name": "outA"}],
                    "base_classes": ["FallbackType"]
                }
            }
        },
        "node2": {
            "data": {
                "type": "TypeY",
                "node": {
                    "template": {
                        "inB": {"input_types": ["str"], "type": "str"}
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_basic_expansion_with_missing_source_output_uses_base_classes():
    """
    Basic: Source node outputs does not contain the requested output, should fallback to base_classes.
    """
    compact_edge = CompactEdge("node1", "nonexistent", "node2", "inB")
    expanded_nodes = {
        "node1": {
            "data": {
                "type": "TypeX",
                "node": {
                    "outputs": [{"name": "outA", "types": ["int"]}],
                    "base_classes": ["BaseX"]
                }
            }
        },
        "node2": {
            "data": {
                "type": "TypeY",
                "node": {
                    "template": {
                        "inB": {"input_types": ["str"], "type": "str"}
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_basic_expansion_with_missing_input_types_uses_field_type():
    """
    Basic: Target node template field missing input_types, should use [type].
    """
    compact_edge = CompactEdge("node1", "outA", "node2", "inB")
    expanded_nodes = {
        "node1": {
            "data": {
                "type": "TypeX",
                "node": {
                    "outputs": [{"name": "outA", "types": ["int"]}],
                    "base_classes": ["BaseX"]
                }
            }
        },
        "node2": {
            "data": {
                "type": "TypeY",
                "node": {
                    "template": {
                        "inB": {"type": "float"}
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output


def test_edge_missing_source_node_raises():
    """
    Edge: Source node is missing from expanded_nodes.
    """
    compact_edge = CompactEdge("missing", "outA", "node2", "inB")
    expanded_nodes = {
        "node2": {
            "data": {
                "type": "TypeY",
                "node": {
                    "template": {
                        "inB": {"input_types": ["str"], "type": "str"}
                    }
                }
            }
        }
    }
    with pytest.raises(ValueError) as excinfo:
        _expand_edge(compact_edge, expanded_nodes)

def test_edge_missing_target_node_raises():
    """
    Edge: Target node is missing from expanded_nodes.
    """
    compact_edge = CompactEdge("node1", "outA", "missing", "inB")
    expanded_nodes = {
        "node1": {
            "data": {
                "type": "TypeX",
                "node": {
                    "outputs": [{"name": "outA", "types": ["int"]}],
                    "base_classes": ["BaseX"]
                }
            }
        }
    }
    with pytest.raises(ValueError) as excinfo:
        _expand_edge(compact_edge, expanded_nodes)

def test_edge_source_node_missing_outputs_and_base_classes():
    """
    Edge: Source node has neither outputs nor base_classes.
    """
    compact_edge = CompactEdge("node1", "outA", "node2", "inB")
    expanded_nodes = {
        "node1": {
            "data": {
                "type": "TypeX",
                "node": {
                    # No outputs, no base_classes
                }
            }
        },
        "node2": {
            "data": {
                "type": "TypeY",
                "node": {
                    "template": {
                        "inB": {"input_types": ["str"], "type": "str"}
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_edge_target_node_missing_template():
    """
    Edge: Target node has no template.
    """
    compact_edge = CompactEdge("node1", "outA", "node2", "inB")
    expanded_nodes = {
        "node1": {
            "data": {
                "type": "TypeX",
                "node": {
                    "outputs": [{"name": "outA", "types": ["int"]}],
                    "base_classes": ["BaseX"]
                }
            }
        },
        "node2": {
            "data": {
                "type": "TypeY",
                "node": {
                    # No template
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output


def test_edge_output_and_input_types_are_empty_lists():
    """
    Edge: Both output_types and input_types are empty lists.
    """
    compact_edge = CompactEdge("node1", "outA", "node2", "inB")
    expanded_nodes = {
        "node1": {
            "data": {
                "type": "TypeX",
                "node": {
                    "outputs": [{"name": "outA", "types": []}],
                    "base_classes": []
                }
            }
        },
        "node2": {
            "data": {
                "type": "TypeY",
                "node": {
                    "template": {
                        "inB": {"input_types": [], "type": "str"}
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

# ----------- LARGE SCALE TEST CASES -----------

def test_large_scale_many_nodes_and_edges():
    """
    Large Scale: Test with many nodes and one edge connecting the first and last.
    """
    N = 500  # Keep under 1000 for performance
    expanded_nodes = {}
    for i in range(N):
        expanded_nodes[f"node{i}"] = {
            "data": {
                "type": f"Type{i}",
                "node": {
                    "outputs": [{"name": f"out{i}", "types": [f"type{i}"]}],
                    "base_classes": [f"Base{i}"],
                    "template": {f"in{i}": {"input_types": [f"type{i}"], "type": f"type{i}"}}
                }
            }
        }
    # Edge from first to last node
    compact_edge = CompactEdge("node0", "out0", f"node{N-1}", f"in{N-1}")
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_large_scale_edge_with_max_length_output_types_and_input_types():
    """
    Large Scale: Output and input types lists are very long.
    """
    output_types = [f"type{i}" for i in range(200)]
    input_types = [f"itype{i}" for i in range(200)]
    compact_edge = CompactEdge("node1", "outA", "node2", "inB")
    expanded_nodes = {
        "node1": {
            "data": {
                "type": "TypeX",
                "node": {
                    "outputs": [{"name": "outA", "types": output_types}],
                    "base_classes": ["BaseX"]
                }
            }
        },
        "node2": {
            "data": {
                "type": "TypeY",
                "node": {
                    "template": {
                        "inB": {"input_types": input_types, "type": "str"}
                    }
                }
            }
        }
    }
    codeflash_output = _expand_edge(compact_edge, expanded_nodes); result = codeflash_output

def test_large_scale_multiple_edges():
    """
    Large Scale: Create and expand multiple edges between nodes.
    """
    N = 100  # Number of nodes/edges
    expanded_nodes = {}
    for i in range(N):
        expanded_nodes[f"node{i}"] = {
            "data": {
                "type": f"Type{i}",
                "node": {
                    "outputs": [{"name": f"out{i}", "types": [f"type{i}"]}],
                    "base_classes": [f"Base{i}"],
                    "template": {f"in{i}": {"input_types": [f"type{i}"], "type": f"type{i}"}}
                }
            }
        }
    # Create edges between consecutive nodes
    for i in range(N - 1):
        compact_edge = CompactEdge(f"node{i}", f"out{i}", f"node{i+1}", f"in{i+1}")
        codeflash_output = _expand_edge(compact_edge, expanded_nodes); 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.

To edit these changes git checkout codeflash/optimize-pr10785-2025-11-28T20.23.51 and push.

[coderabbitai]

Important

Review skipped

Bot user detected.

To trigger a single review, invoke the @coderabbitai review command.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[codecov]

Codecov Report

❌ Patch coverage is 96.15385% with 1 line in your changes missing coverage. Please review.
✅ Project coverage is 32.49%. Comparing base (17dc372) to head (a8adf0f).

Files with missing lines	Patch %	Lines
...rc/backend/base/langflow/processing/expand_flow.py	96.15%	1 Missing ⚠️

❌ Your project check has failed because the head coverage (40.04%) is below the target coverage (60.00%). You can increase the head coverage or adjust the target coverage.

Additional details and impacted files

@@                        Coverage Diff                        @@
##           feat/no-code-pre-built-component   #10787   +/-   ##
=================================================================
  Coverage                             32.48%   32.49%           
=================================================================
  Files                                  1369     1369           
  Lines                                 63516    63526   +10     
  Branches                               9373     9373           
=================================================================
+ Hits                                  20633    20641    +8     
- Misses                                41850    41852    +2     
  Partials                               1033     1033           

Flag	Coverage Δ
backend	51.50% <96.15%> (+0.01%)	⬆️
lfx	40.04% <ø> (ø)

Flags with carried forward coverage won't be shown. Click here to find out more.

Files with missing lines	Coverage Δ
...rc/backend/base/langflow/processing/expand_flow.py	93.75% <96.15%> (-3.93%)	⬇️

... and 3 files with indirect coverage changes

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.