refactor: (codeflash) ⚡️ Speed up function get_successors by 20%

[misrasaurabh1]

📄 get_successors in src/backend/base/langflow/graph/graph/utils.py

✨ Performance Summary:

• Speed Increase: 📈 20% (0.20x faster)
• Runtime Reduction: ⏱️ From 107 microseconds down to 88.5 microseconds (best of 44 runs)

---

📝 Explanation and details

Certainly! The initial code includes some redundancy in checking and processing nodes, which can be optimized to reduce unnecessary operations. Here's an improved version of the program.

Key Optimizations.

1. Avoid unnecessary checks - We start by initializing the stack with the direct successors of the given vertex_id, so there's no need to recheck the initial vertex.
2. Use set operations efficiently - By using a set to keep track of visited nodes, we ensure O(1) complexity for the check and add operations, instead of checking it each time later.
3. Reduce redundant operations - Only push successors that haven't been visited to avoid redundant checks within the loop.

Further runtime improvements could involve specific optimizations depending on the characteristics of the graph and the operations' patterns if any additional details are provided.

---

✅ Correctness verification

The new optimized code was tested for correctness. The results are listed below:

Test	Status	Details
⚙️ Existing Unit Tests	✅ 51 Passed	See below
🌀 Generated Regression Tests	✅ 25 Passed	See below
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Coverage	100.0%

⚙️ Existing Unit Tests Details

Click to view details

- graph/graph/test_utils.py

🌀 Generated Regression Tests Details

Click to view details

import pytest  # used for our unit tests
from langflow.graph.graph.utils import get_successors

# unit tests

def test_single_vertex_no_successors():
    graph = {'A': {'successors': []}}
    codeflash_output = get_successors(graph, 'A')

def test_single_vertex_one_successor():
    graph = {'A': {'successors': ['B']}, 'B': {'successors': []}}
    codeflash_output = get_successors(graph, 'A')

def test_multiple_vertices_linear_successors():
    graph = {'A': {'successors': ['B']}, 'B': {'successors': ['C']}, 'C': {'successors': []}}
    codeflash_output = get_successors(graph, 'A')

def test_branching_graph():
    graph = {'A': {'successors': ['B', 'C']}, 'B': {'successors': ['D']}, 'C': {'successors': []}, 'D': {'successors': []}}
    codeflash_output = get_successors(graph, 'A')

def test_graph_with_cycles():
    graph = {'A': {'successors': ['B']}, 'B': {'successors': ['C']}, 'C': {'successors': ['A']}}
    codeflash_output = get_successors(graph, 'A')

def test_disconnected_graph():
    graph = {'A': {'successors': ['B']}, 'B': {'successors': []}, 'C': {'successors': ['D']}, 'D': {'successors': []}}
    codeflash_output = get_successors(graph, 'A')


def test_vertex_with_self_loop():
    graph = {'A': {'successors': ['A']}}
    codeflash_output = get_successors(graph, 'A')

def test_vertex_with_multiple_successors():
    graph = {'A': {'successors': ['B', 'C', 'D']}, 'B': {'successors': []}, 'C': {'successors': []}, 'D': {'successors': []}}
    codeflash_output = get_successors(graph, 'A')

def test_large_linear_graph():
    graph = {chr(i): {'successors': [chr(i+1)]} for i in range(65, 90)}
    graph['Z'] = {'successors': []}
    expected_result = [chr(i) for i in range(66, 91)]
    codeflash_output = get_successors(graph, 'A')

def test_large_branching_graph():
    graph = {'A': {'successors': [chr(i) for i in range(66, 91)]}}
    for i in range(66, 91):
        graph[chr(i)] = {'successors': []}
    codeflash_output = get_successors(graph, 'A')
    expected_result = [chr(i) for i in range(66, 91)]

def test_deeply_nested_graph():
    graph = {chr(i): {'successors': [chr(i+1)]} for i in range(65, 90)}
    graph['Z'] = {'successors': ['A']}
    expected_result = [chr(i) for i in range(66, 91)]
    codeflash_output = get_successors(graph, 'A')

def test_high_fan_out_graph():
    graph = {'A': {'successors': [chr(i) for i in range(66, 91)]}}
    for i in range(66, 91):
        graph[chr(i)] = {'successors': []}
    codeflash_output = get_successors(graph, 'A')
    expected_result = [chr(i) for i in range(66, 91)]
# 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.graph.graph.utils import get_successors

# unit tests

def test_single_vertex_no_successors():
    graph = {"A": {"successors": []}}
    codeflash_output = get_successors(graph, "A")

def test_single_vertex_one_successor():
    graph = {"A": {"successors": ["B"]}, "B": {"successors": []}}
    codeflash_output = get_successors(graph, "A")

def test_multiple_vertices_linear_successors():
    graph = {"A": {"successors": ["B"]}, "B": {"successors": ["C"]}, "C": {"successors": []}}
    codeflash_output = get_successors(graph, "A")

def test_single_vertex_self_loop():
    graph = {"A": {"successors": ["A"]}}
    codeflash_output = get_successors(graph, "A")

def test_multiple_vertices_with_cycle():
    graph = {"A": {"successors": ["B"]}, "B": {"successors": ["C"]}, "C": {"successors": ["A"]}}
    codeflash_output = get_successors(graph, "A")



def test_vertex_multiple_successors():
    graph = {"A": {"successors": ["B", "C"]}, "B": {"successors": []}, "C": {"successors": []}}
    codeflash_output = get_successors(graph, "A")

def test_complex_graph_multiple_successors():
    graph = {"A": {"successors": ["B", "C"]}, "B": {"successors": ["D"]}, "C": {"successors": ["E"]}, "D": {"successors": []}, "E": {"successors": []}}
    codeflash_output = get_successors(graph, "A")


def test_vertex_not_in_graph():
    graph = {"A": {"successors": ["B"]}}
    with pytest.raises(KeyError):
        get_successors(graph, "C")

def test_graph_missing_successors_key():
    graph = {"A": {"successors": ["B"]}, "B": {}}
    with pytest.raises(KeyError):
        get_successors(graph, "A")

def test_large_graph_many_vertices_edges():
    graph = {"A": {"successors": ["B", "C", "D"]}, "B": {"successors": ["E", "F"]}, "C": {"successors": ["G", "H"]}, "D": {"successors": ["I", "J"]}, "E": {"successors": []}, "F": {"successors": []}, "G": {"successors": []}, "H": {"successors": []}, "I": {"successors": []}, "J": {"successors": []}}
    codeflash_output = get_successors(graph, "A")


def test_graph_with_integer_vertex_ids():
    graph = {1: {"successors": [2]}, 2: {"successors": [3]}, 3: {"successors": []}}
    codeflash_output = get_successors(graph, 1)

def test_graph_with_mixed_type_vertex_ids():
    graph = {1: {"successors": ["A"]}, "A": {"successors": [2]}, 2: {"successors": []}}
    codeflash_output = get_successors(graph, 1)

# Run the tests
if __name__ == "__main__":
    pytest.main()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

---

📣 **Feedback**

If you have any feedback or need assistance, feel free to join our Discord community:

[codspeed-hq]

CodSpeed Performance Report

Merging #5390 will degrade performances by 18.2%

_{Comparing codeflash-ai:codeflash/optimize-get_successors-2024-12-11T14.11.20 (de6f2b3) with main (243055e)}

Summary

⚡ 1 improvements
❌ 2 regressions
✅ 12 untouched benchmarks

⚠️ Please fix the performance issues or acknowledge them on CodSpeed.

Benchmarks breakdown

	Benchmark	main	codeflash-ai:codeflash/optimize-get_successors-2024-12-11T14.11.20	Change
⚡	test_setup_llm_caching	2.1 ms	1.2 ms	+76.5%
❌	test_successful_run_with_output_type_any	203 ms	248.2 ms	-18.2%
❌	test_successful_run_with_output_type_debug	225.1 ms	257.9 ms	-12.72%