⚡️ Speed up function repeat by 12%

[codeflash-ai]

📄 12% (0.12x) speedup for repeat in src/bokeh/driving.py

⏱️ Runtime : 17.0 microseconds → 15.2 microseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 12% speedup through two key micro-optimizations that reduce function call overhead and variable lookup costs:

Key Optimizations:

1. Direct method binding in force(): Replaced next(sequence) with sequence.__next__() by storing a local reference next_sequence = sequence.__next__. This eliminates the global lookup for the next builtin function and removes one layer of function call indirection, providing faster access in tight loops.

2. Closure variable optimization in repeat(): Changed the inner function f from a closure that captures sequence and N to using default arguments f(i: int, sequence=sequence, N=N). This is significantly faster because accessing default arguments is cheaper than dereferencing closure cells in Python.

Performance Impact:

The line profiler shows the optimizations are most effective in the hot path - the yield f(i) line in _advance() which accounts for ~57% of total execution time. Since this line is called thousands of times (3,565 hits in the profile), even small per-call improvements compound significantly.

Test Case Analysis:

The optimizations particularly benefit scenarios with:

• High iteration counts: Tests like test_repeat_large_scale_long_run (1000 iterations) and test_repeat_large_scale_performance see the most benefit
• Frequent generator advancement: Any workload that repeatedly calls the returned driver function will benefit from the reduced overhead

The changes preserve all functionality and behavior - the optimizations are purely performance-focused micro-optimizations that leverage Python's internal implementation details for faster variable access patterns.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
unit/bokeh/test_driving.py::test_repeat	955ns	816ns	17.0%✅

🌀 Generated Regression Tests and Runtime

from functools import partial
from typing import Any, Callable, Iterator, Sequence, TypeVar

# imports
import pytest  # used for our unit tests
from bokeh.driving import repeat

# unit tests

# Helper function to extract values generated by the repeat driver
def get_repeat_values(seq, n):
    """Helper to extract n values from repeat(seq) driver."""
    values = []
    result = []
    def collect(x):
        result.append(x)
    driver = repeat(seq)(collect)
    for _ in range(n):
        driver()
    return result

# 1. Basic Test Cases




def test_repeat_basic_type_preservation():
    # Should preserve types of elements in the sequence
    seq = [1, 'a', 3.5]
    values = get_repeat_values(seq, 5)

# 2. Edge Test Cases

def test_repeat_edge_negative_numbers():
    # Sequence with negative numbers should repeat correctly
    seq = [-1, -2, -3]
    values = get_repeat_values(seq, 4)

def test_repeat_edge_mixed_types():
    # Sequence with mixed types (int, str, float, bool)
    seq = [0, 'x', 2.5, True]
    values = get_repeat_values(seq, 6)

def test_repeat_edge_tuple_as_sequence():
    # Sequence can be a tuple
    seq = (5, 6)
    values = get_repeat_values(seq, 5)

def test_repeat_edge_string_as_sequence():
    # Sequence can be a string (should repeat characters)
    seq = "abc"
    values = get_repeat_values(seq, 5)

def test_repeat_edge_list_with_none():
    # Sequence with None values
    seq = [None, 1]
    values = get_repeat_values(seq, 3)



def test_repeat_large_scale_1000_elements():
    # Large sequence, repeat should cycle through all elements
    seq = list(range(1000))
    values = get_repeat_values(seq, 1003)

def test_repeat_large_scale_long_run():
    # Small sequence, many iterations
    seq = [7, 8]
    values = get_repeat_values(seq, 1000)

def test_repeat_large_scale_performance():
    # Should not be excessively slow for 1000 iterations
    import time
    seq = [0, 1, 2, 3, 4]
    start = time.time()
    values = get_repeat_values(seq, 1000)
    duration = time.time() - start
    # Sanity check: correct cycling
    for i, v in enumerate(values):
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from functools import partial
from typing import Any, Callable, Iterator, Sequence, TypeVar

# imports
import pytest  # used for our unit tests
from bokeh.driving import repeat

# unit tests

# Helper function to extract repeated values from the driver
def get_repeated_values(driver, n):
    """Helper to get n repeated values from the driver function."""
    results = []
    def collect(x):
        results.append(x)
    drv = driver(collect)
    for _ in range(n):
        drv()
    return results

# 1. Basic Test Cases

from bokeh.driving import repeat

def test_repeat():
    repeat(())

To edit these changes git checkout codeflash/optimize-repeat-mhwjpz7q and push.