⚡️ Speed up function _handle_sublists by 16%

[codeflash-ai]

📄 16% (0.16x) speedup for _handle_sublists in src/bokeh/plotting/graph.py

⏱️ Runtime : 824 microseconds → 707 microseconds (best of 250 runs)

📝 Explanation and details

The optimization replaces two separate generator expressions (any() and all()) with explicit for loops that provide better short-circuiting behavior and avoid multiple iterations over the input values.

Key optimizations:

1. Single-pass detection: Instead of using any(isinstance(x, (list, tuple)) for x in values) which iterates through all values, the optimized version uses a manual loop that breaks immediately upon finding the first non-scalar element, setting has_non_scalar = True.

2. Early exit validation: The validation loop that checks for mixed types also exits immediately when finding the first invalid element, rather than checking all elements via all().

3. Reduced iterations: The original code potentially iterates through values three times (once for any(), once for all(), once for the list comprehension), while the optimized version only iterates twice maximum.

Performance impact:

• Scalar-only cases see the biggest gains (60-90% faster) because the optimization immediately identifies no non-scalars exist after checking just the first few elements
• Large datasets benefit from avoiding redundant iterations, showing 11-22% speedup on 1000-element lists
• Error cases (mixed types) are 45-75% faster due to early exit when detecting the first type mismatch

Context relevance:
The function is called within from_networkx() which processes NetworkX graph node and edge attributes. This is likely in a hot path when converting large graphs, making the 16% overall speedup meaningful for graph visualization workflows. The optimization particularly benefits scenarios with many scalar attributes (common in graph data) while maintaining identical error handling and output behavior.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from bokeh.plotting.graph import _handle_sublists

# unit tests

# --- Basic Test Cases ---

def test_all_scalars_int():
    # All elements are scalars (ints)
    values = [1, 2, 3]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 1.46μs -> 884ns (64.9% faster)

def test_all_scalars_str():
    # All elements are scalars (str)
    values = ["a", "b", "c"]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 1.28μs -> 762ns (68.2% faster)

def test_all_lists():
    # All elements are lists
    values = [[1, 2], [3, 4], [5]]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 2.59μs -> 1.68μs (54.5% faster)

def test_all_tuples():
    # All elements are tuples
    values = [(1, 2), (3,), (4, 5)]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 2.58μs -> 1.80μs (43.0% faster)

def test_lists_and_none():
    # Lists and None values
    values = [[1], None, [2, 3]]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 2.35μs -> 1.56μs (50.7% faster)

def test_tuples_and_none():
    # Tuples and None values
    values = [(1,), None, (2, 3)]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 2.63μs -> 1.73μs (52.2% faster)

def test_mixed_lists_and_tuples():
    # Mix of lists and tuples
    values = [(1, 2), [3, 4], (5,)]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 2.67μs -> 1.82μs (46.4% faster)

# --- Edge Test Cases ---

def test_empty_list():
    # Empty input list
    values = []
    codeflash_output = _handle_sublists(values); result = codeflash_output # 811ns -> 386ns (110% faster)

def test_all_none():
    # All elements are None
    values = [None, None]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 1.25μs -> 725ns (72.7% faster)

def test_mixed_scalars_and_list_raises():
    # Mix of scalars and lists should raise ValueError
    values = [1, [2, 3], 4]
    with pytest.raises(ValueError):
        _handle_sublists(values) # 2.30μs -> 1.42μs (62.6% faster)

def test_mixed_scalars_and_tuple_raises():
    # Mix of scalars and tuples should raise ValueError
    values = [1, (2, 3), 4]
    with pytest.raises(ValueError):
        _handle_sublists(values) # 2.40μs -> 1.49μs (61.2% faster)

def test_mixed_list_tuple_and_none():
    # Mix of lists, tuples, and None
    values = [[], (1,), None]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 2.67μs -> 1.81μs (47.7% faster)

def test_nested_lists():
    # Nested lists (should treat outer list only)
    values = [[1, [2, 3]], [4]]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 2.17μs -> 1.41μs (54.4% faster)

def test_single_scalar():
    # Single scalar value in a list
    values = [42]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 1.07μs -> 630ns (70.3% faster)

def test_single_list():
    # Single list value in a list
    values = [[1, 2, 3]]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 2.04μs -> 1.27μs (61.0% faster)

def test_single_tuple():
    # Single tuple value in a list
    values = [(1, 2)]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 2.24μs -> 1.47μs (52.5% faster)

def test_list_with_empty_list_and_none():
    # List with empty list and None
    values = [[], None, []]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 2.30μs -> 1.51μs (51.8% faster)

def test_list_with_none_and_scalar():
    # List with None and scalar (should not convert None)
    values = [None, 1, None]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 1.30μs -> 811ns (60.2% faster)

def test_list_with_none_and_tuple_and_scalar_raises():
    # List with None, tuple, and scalar (should raise)
    values = [None, (1,), 2]
    with pytest.raises(ValueError):
        _handle_sublists(values) # 2.60μs -> 1.62μs (60.8% faster)

def test_list_with_bool_and_list_raises():
    # List with bool and list (should raise)
    values = [True, [1, 2], False]
    with pytest.raises(ValueError):
        _handle_sublists(values) # 2.48μs -> 1.43μs (73.7% faster)

def test_list_with_float_and_tuple_raises():
    # List with float and tuple (should raise)
    values = [1.5, (2, 3), 2.5]
    with pytest.raises(ValueError):
        _handle_sublists(values) # 2.26μs -> 1.45μs (55.6% faster)

def test_list_with_dict_and_list_raises():
    # List with dict and list (should raise)
    values = [{"a": 1}, [1, 2], {"b": 2}]
    with pytest.raises(ValueError):
        _handle_sublists(values) # 2.08μs -> 1.43μs (45.3% faster)

def test_list_with_set_and_tuple_raises():
    # List with set and tuple (should raise)
    values = [{1, 2}, (3, 4), {5}]
    with pytest.raises(ValueError):
        _handle_sublists(values) # 2.56μs -> 1.58μs (62.5% faster)

def test_list_with_custom_object_and_list_raises():
    # List with custom object and list (should raise)
    class Foo:
        pass
    values = [Foo(), [1, 2], Foo()]
    with pytest.raises(ValueError):
        _handle_sublists(values) # 2.40μs -> 1.62μs (48.0% faster)

# --- Large Scale Test Cases ---

def test_large_all_scalars():
    # Large list of scalars
    values = list(range(1000))
    codeflash_output = _handle_sublists(values); result = codeflash_output # 56.7μs -> 46.5μs (21.8% faster)

def test_large_all_lists():
    # Large list of lists
    values = [[i, i+1] for i in range(1000)]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 79.7μs -> 71.3μs (11.8% faster)

def test_large_all_tuples():
    # Large list of tuples
    values = [(i, i+1) for i in range(1000)]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 88.7μs -> 78.9μs (12.4% faster)

def test_large_lists_and_none():
    # Large list of lists and None
    values = [[i] if i % 2 == 0 else None for i in range(1000)]
    expected = [[i] if i % 2 == 0 else [] for i in range(1000)]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 58.3μs -> 54.6μs (6.91% faster)

def test_large_mixed_scalars_and_lists_raises():
    # Large list with mix of scalars and lists, should raise
    values = [i if i % 2 == 0 else [i] for i in range(1000)]
    with pytest.raises(ValueError):
        _handle_sublists(values) # 2.37μs -> 1.49μs (59.0% faster)

def test_large_mixed_scalars_and_tuples_raises():
    # Large list with mix of scalars and tuples, should raise
    values = [i if i % 2 == 0 else (i,) for i in range(1000)]
    with pytest.raises(ValueError):
        _handle_sublists(values) # 2.50μs -> 1.61μs (55.5% faster)

def test_large_lists_and_tuples_and_none():
    # Large list with lists, tuples, and None
    values = [[i] if i % 3 == 0 else (i,) if i % 3 == 1 else None for i in range(1000)]
    expected = [[i] if i % 3 == 0 else [i] if i % 3 == 1 else [] for i in range(1000)]
    codeflash_output = _handle_sublists(values); result = codeflash_output # 70.5μs -> 65.8μs (7.17% faster)

def test_large_all_none():
    # Large list of None
    values = [None] * 1000
    codeflash_output = _handle_sublists(values); result = codeflash_output # 55.9μs -> 46.2μs (21.1% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest
from bokeh.plotting.graph import _handle_sublists

# unit tests

# ------------------------
# Basic Test Cases
# ------------------------

def test_all_scalars_ints():
    # All elements are scalars (ints)
    codeflash_output = _handle_sublists([1, 2, 3]) # 1.28μs -> 748ns (71.5% faster)

def test_all_scalars_floats():
    # All elements are scalars (floats)
    codeflash_output = _handle_sublists([1.1, 2.2, 3.3]) # 1.23μs -> 745ns (65.4% faster)

def test_all_scalars_strings():
    # All elements are scalars (strings)
    codeflash_output = _handle_sublists(['a', 'b', 'c']) # 1.26μs -> 725ns (73.5% faster)

def test_all_lists():
    # All elements are lists
    codeflash_output = _handle_sublists([[1], [2, 3], [4]]) # 2.61μs -> 1.67μs (56.3% faster)

def test_all_tuples():
    # All elements are tuples
    codeflash_output = _handle_sublists([(1,), (2, 3), (4,)]) # 2.56μs -> 1.83μs (39.8% faster)

def test_all_lists_and_tuples():
    # All elements are lists or tuples
    codeflash_output = _handle_sublists([[1], (2, 3), [4, 5]]) # 2.54μs -> 1.72μs (47.6% faster)

def test_lists_with_none():
    # Some elements are None, should be replaced with []
    codeflash_output = _handle_sublists([[1], None, (2, 3)]) # 2.41μs -> 1.65μs (46.4% faster)

def test_all_nones():
    # All elements are None and at least one is a (list, tuple)
    codeflash_output = _handle_sublists([None, None, None]) # 1.31μs -> 748ns (75.0% faster)

# ------------------------
# Edge Test Cases
# ------------------------

def test_empty_list():
    # Input is an empty list
    codeflash_output = _handle_sublists([]) # 770ns -> 389ns (97.9% faster)

def test_mixed_scalar_and_list():
    # Mixing scalars and lists should raise ValueError
    with pytest.raises(ValueError):
        _handle_sublists([1, [2, 3], 4]) # 2.27μs -> 1.42μs (60.0% faster)

def test_mixed_scalar_and_tuple():
    # Mixing scalars and tuples should raise ValueError
    with pytest.raises(ValueError):
        _handle_sublists(['a', (2, 3), 'b']) # 2.37μs -> 1.46μs (62.2% faster)

def test_mixed_scalar_and_list_with_none():
    # Mixing scalars, lists, and None should raise ValueError
    with pytest.raises(ValueError):
        _handle_sublists([1, [2, 3], None]) # 2.14μs -> 1.29μs (65.9% faster)

def test_all_none_with_list():
    # All elements are None, but at least one is a list
    codeflash_output = _handle_sublists([None, [], None]) # 2.46μs -> 1.68μs (46.3% faster)

def test_nested_lists():
    # Nested lists should be treated as non-scalars, but not flattened
    codeflash_output = _handle_sublists([[[1]], [[2, 3]], [[4]]]) # 2.28μs -> 1.55μs (46.7% faster)

def test_single_element_list():
    # Single element that is a list
    codeflash_output = _handle_sublists([[1, 2, 3]]) # 1.93μs -> 1.26μs (52.8% faster)

def test_single_element_scalar():
    # Single element that is a scalar
    codeflash_output = _handle_sublists([42]) # 1.08μs -> 574ns (87.8% faster)

def test_single_element_none():
    # Single element that is None
    codeflash_output = _handle_sublists([None]) # 1.05μs -> 583ns (81.0% faster)

def test_list_with_all_empty_lists():
    # All elements are empty lists
    codeflash_output = _handle_sublists([[], [], []]) # 2.41μs -> 1.53μs (57.6% faster)

def test_list_with_empty_and_nonempty_lists():
    # Mix of empty and non-empty lists
    codeflash_output = _handle_sublists([[], [1], [2, 3]]) # 2.33μs -> 1.50μs (56.2% faster)

def test_list_with_tuple_and_none():
    # Mix of tuple and None
    codeflash_output = _handle_sublists([(1, 2), None, (3,)]) # 2.52μs -> 1.74μs (44.8% faster)

def test_list_with_list_and_none():
    # Mix of list and None
    codeflash_output = _handle_sublists([[1, 2], None, [3]]) # 2.18μs -> 1.46μs (49.6% faster)

def test_list_with_tuple_and_list():
    # Mix of tuple and list
    codeflash_output = _handle_sublists([(1, 2), [3, 4]]) # 2.55μs -> 1.69μs (50.8% faster)

def test_list_with_tuple_list_and_none():
    # Mix of tuple, list, and None
    codeflash_output = _handle_sublists([(1, 2), [3, 4], None]) # 2.58μs -> 1.78μs (45.5% faster)

def test_list_with_nonetype_and_scalar():
    # Mix of None and scalar, should not convert None
    codeflash_output = _handle_sublists([None, 1, None]) # 1.29μs -> 773ns (66.9% faster)

def test_list_with_nonetype_and_tuple():
    # Mix of None and tuple, should convert None to []
    codeflash_output = _handle_sublists([None, (1, 2), None]) # 2.73μs -> 1.75μs (56.3% faster)

def test_list_with_bool_and_list():
    # Mixing bool (scalar) and list should raise ValueError
    with pytest.raises(ValueError):
        _handle_sublists([True, [1, 2]]) # 2.58μs -> 1.50μs (71.6% faster)

def test_list_with_dict_and_list():
    # Mixing dict (scalar for this context) and list should raise ValueError
    with pytest.raises(ValueError):
        _handle_sublists([{'a': 1}, [1, 2]]) # 2.15μs -> 1.53μs (41.0% faster)

# ------------------------
# Large Scale Test Cases
# ------------------------

def test_large_all_scalars():
    # Large list of scalars
    data = list(range(1000))
    codeflash_output = _handle_sublists(data) # 56.6μs -> 46.2μs (22.5% faster)

def test_large_all_lists():
    # Large list of lists
    data = [[i, i+1] for i in range(1000)]
    expected = [[i, i+1] for i in range(1000)]
    codeflash_output = _handle_sublists(data) # 98.6μs -> 90.5μs (8.94% faster)

def test_large_all_tuples():
    # Large list of tuples
    data = [(i, i+1) for i in range(1000)]
    expected = [[i, i+1] for i in range(1000)]
    codeflash_output = _handle_sublists(data) # 88.6μs -> 79.7μs (11.1% faster)

def test_large_lists_with_nones():
    # Large list with lists and None
    data = [[i, i+1] if i % 2 == 0 else None for i in range(1000)]
    expected = [[i, i+1] if i % 2 == 0 else [] for i in range(1000)]
    codeflash_output = _handle_sublists(data) # 57.4μs -> 55.5μs (3.34% faster)

def test_large_mixed_scalars_and_lists_raises():
    # Large list mixing scalars and lists should raise ValueError
    data = [i if i % 2 == 0 else [i, i+1] for i in range(1000)]
    with pytest.raises(ValueError):
        _handle_sublists(data) # 2.40μs -> 1.49μs (61.2% faster)
# 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-_handle_sublists-mhwcs44t and push.