⚡️ Speed up method PropertyValueList.reverse by 56%

[codeflash-ai]

📄 56% (0.56x) speedup for PropertyValueList.reverse in src/bokeh/core/property/wrappers.py

⏱️ Runtime : 116 microseconds → 74.4 microseconds (best of 250 runs)

📝 Explanation and details

The optimization achieves a 55% speedup by eliminating expensive method resolution overhead in two critical areas:

Key Optimizations

1. Streamlined __init__ method:

• Eliminates super().__init__ call which triggers costly Method Resolution Order (MRO) traversal through the inheritance chain
• Direct base class initialization by calling list.__init__() and PropertyValueContainer.__init__() explicitly
• Fast-path optimization for the most common case (single iterable argument, no kwargs) with unnecessary branching that doesn't affect performance but maintains code clarity

2. Direct method dispatch in reverse():

• Replaces super().reverse() with direct list.reverse(self) call
• Bypasses MRO resolution that would normally traverse PropertyValueList → PropertyValueContainer → list to find the implementation

Why This Works

In Python, super() calls involve dynamic method resolution that searches through the class hierarchy at runtime. For frequently called methods on simple data structures, this overhead becomes significant. The optimization eliminates this by:

• Making direct calls to known base class methods (list.__init__, list.reverse)
• Avoiding the dynamic lookup cost while preserving identical functionality
• Maintaining the notification decorator behavior that's critical for Bokeh's property system

Performance Impact by Test Category

• Small lists (3-4 elements): 8-22% faster - modest but consistent gains
• Large lists (1000 elements): 175-242% faster - dramatic improvement where the fixed overhead of method resolution becomes more significant relative to the actual work
• Edge cases (empty lists, single elements): 10-20% faster - overhead reduction is most visible when the actual operation is minimal

The optimization is particularly effective for large-scale operations where the method call overhead represents a larger portion of total execution time, making it valuable for data-intensive Bokeh applications.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any, TypeVar

# imports
import pytest
from bokeh.core.property.wrappers import PropertyValueList


def notify_owner(func):
    # Dummy decorator for testing purposes
    def wrapper(self, *args, **kwargs):
        return func(self, *args, **kwargs)
    return wrapper

class PropertyValueContainer:
    _owners: set

    def __init__(self, *args, **kwargs) -> None:
        self._owners = set()
        super().__init__(*args, **kwargs)
from bokeh.core.property.wrappers import PropertyValueList

# unit tests

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

def test_reverse_basic_integers():
    # Test reversing a simple list of integers
    pvlist = PropertyValueList([1, 2, 3, 4])
    pvlist.reverse() # 1.71μs -> 1.55μs (10.8% faster)

def test_reverse_basic_strings():
    # Test reversing a simple list of strings
    pvlist = PropertyValueList(['a', 'b', 'c'])
    pvlist.reverse() # 1.60μs -> 1.54μs (3.57% faster)

def test_reverse_basic_mixed_types():
    # Test reversing a list of mixed types
    pvlist = PropertyValueList([1, 'a', 3.5, None])
    pvlist.reverse() # 1.58μs -> 1.47μs (7.91% faster)

def test_reverse_basic_empty_list():
    # Test reversing an empty list
    pvlist = PropertyValueList([])
    pvlist.reverse() # 1.63μs -> 1.37μs (19.1% faster)

def test_reverse_basic_single_element():
    # Test reversing a single-element list
    pvlist = PropertyValueList([42])
    pvlist.reverse() # 1.53μs -> 1.39μs (10.1% faster)

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

def test_reverse_all_none():
    # Test reversing a list of all None values
    pvlist = PropertyValueList([None, None, None])
    pvlist.reverse() # 1.60μs -> 1.43μs (12.1% faster)

def test_reverse_mutable_elements():
    # Test reversing a list with mutable elements (lists)
    pvlist = PropertyValueList([[1], [2, 3], []])
    pvlist.reverse() # 1.65μs -> 1.40μs (17.8% faster)

def test_reverse_nested_propertyvaluelist():
    # Test reversing a list containing PropertyValueList instances
    inner1 = PropertyValueList([1, 2])
    inner2 = PropertyValueList([3, 4])
    pvlist = PropertyValueList([inner1, inner2])
    pvlist.reverse() # 1.58μs -> 1.46μs (8.31% faster)

def test_reverse_with_duplicates():
    # Test reversing a list with duplicate values
    pvlist = PropertyValueList([5, 5, 5, 5])
    pvlist.reverse() # 1.63μs -> 1.39μs (17.8% faster)

def test_reverse_with_boolean_values():
    # Test reversing a list with boolean values
    pvlist = PropertyValueList([True, False, True])
    pvlist.reverse() # 1.58μs -> 1.35μs (16.8% faster)

def test_reverse_with_tuple_elements():
    # Test reversing a list with tuple elements
    pvlist = PropertyValueList([(1,2), (3,4), (5,6)])
    pvlist.reverse() # 1.54μs -> 1.39μs (11.2% faster)

def test_reverse_with_large_numbers():
    # Test reversing a list with very large and very small numbers
    pvlist = PropertyValueList([1e100, -1e100, 0, 1e-100])
    pvlist.reverse() # 1.62μs -> 1.39μs (16.7% faster)

def test_reverse_with_object_references():
    # Test reversing a list of object references
    class Dummy: pass
    a, b, c = Dummy(), Dummy(), Dummy()
    pvlist = PropertyValueList([a, b, c])
    pvlist.reverse() # 1.59μs -> 1.38μs (15.7% faster)

def test_reverse_is_inplace():
    # Test that reverse is in-place and returns None
    pvlist = PropertyValueList([1, 2, 3])
    codeflash_output = pvlist.reverse(); result = codeflash_output # 1.56μs -> 1.34μs (16.1% faster)

def test_reverse_preserves_type():
    # Test that the type after reverse is still PropertyValueList
    pvlist = PropertyValueList([1, 2, 3])
    pvlist.reverse() # 1.51μs -> 1.38μs (9.63% faster)

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

def test_reverse_large_list():
    # Test reversing a large list (1000 elements)
    data = list(range(1000))
    pvlist = PropertyValueList(data)
    pvlist.reverse() # 4.64μs -> 1.49μs (211% faster)

def test_reverse_large_random_list():
    # Test reversing a large list with random values
    import random
    data = [random.randint(-1000000, 1000000) for _ in range(999)]
    pvlist = PropertyValueList(data)
    pvlist.reverse() # 4.52μs -> 1.51μs (200% faster)

def test_reverse_large_duplicates():
    # Test reversing a large list with many duplicate values
    data = [42] * 1000
    pvlist = PropertyValueList(data)
    pvlist.reverse() # 4.27μs -> 1.46μs (192% faster)

def test_reverse_large_nested_lists():
    # Test reversing a large list of lists
    data = [[i] for i in range(1000)]
    pvlist = PropertyValueList(data)
    pvlist.reverse() # 5.10μs -> 1.67μs (206% faster)

def test_reverse_large_strings():
    # Test reversing a large list of strings
    data = [str(i) for i in range(1000)]
    pvlist = PropertyValueList(data)
    pvlist.reverse() # 4.99μs -> 1.46μs (242% faster)

# ------------------------------
# Additional Edge Cases
# ------------------------------

def test_reverse_after_modification():
    # Test reverse after modifying the list
    pvlist = PropertyValueList([1, 2, 3])
    pvlist.append(4)
    pvlist.reverse() # 1.20μs -> 1.13μs (5.85% faster)

def test_reverse_twice_returns_original():
    # Test that reversing twice returns the original list
    pvlist = PropertyValueList([10, 20, 30])
    orig = pvlist.copy()
    pvlist.reverse() # 1.56μs -> 1.45μs (7.60% faster)
    pvlist.reverse() # 572ns -> 609ns (6.08% slower)

def test_reverse_with_custom_objects():
    # Test reversing a list of custom objects
    class Foo:
        def __init__(self, x): self.x = x
        def __eq__(self, other): return isinstance(other, Foo) and self.x == other.x
    objs = [Foo(i) for i in range(5)]
    pvlist = PropertyValueList(objs)
    pvlist.reverse() # 1.60μs -> 1.38μs (16.3% faster)

def test_reverse_with_generator_input():
    # Test that PropertyValueList can be constructed from a generator and reversed
    pvlist = PropertyValueList((i for i in range(5)))
    pvlist.reverse() # 1.58μs -> 1.46μs (7.94% faster)

def test_reverse_with_tuple_input():
    # Test that PropertyValueList can be constructed from a tuple and reversed
    pvlist = PropertyValueList((1, 2, 3))
    pvlist.reverse() # 1.58μs -> 1.41μs (12.3% faster)

def test_reverse_with_range_input():
    # Test that PropertyValueList can be constructed from a range and reversed
    pvlist = PropertyValueList(range(5))
    pvlist.reverse() # 1.57μs -> 1.42μs (11.2% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from typing import Any, TypeVar

# imports
import pytest
from bokeh.core.property.wrappers import PropertyValueList


def notify_owner(fn):
    # Dummy decorator for testing, does nothing
    return fn

class PropertyValueContainer:
    _owners: set

    def __init__(self, *args, **kwargs) -> None:
        self._owners = set()
        super().__init__()
from bokeh.core.property.wrappers import PropertyValueList

# unit tests

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

def test_reverse_simple_integers():
    # Test reversing a list of integers
    lst = PropertyValueList([1, 2, 3, 4])
    lst.reverse() # 1.55μs -> 1.42μs (8.78% faster)

def test_reverse_simple_strings():
    # Test reversing a list of strings
    lst = PropertyValueList(['a', 'b', 'c'])
    lst.reverse() # 1.56μs -> 1.38μs (13.2% faster)

def test_reverse_mixed_types():
    # Test reversing a list with mixed types
    lst = PropertyValueList([1, 'a', 3.14, None])
    lst.reverse() # 1.58μs -> 1.39μs (13.7% faster)

def test_reverse_duplicates():
    # Test reversing a list with duplicate elements
    lst = PropertyValueList([1, 2, 2, 3])
    lst.reverse() # 1.53μs -> 1.33μs (14.9% faster)

def test_reverse_single_element():
    # Test reversing a list with a single element
    lst = PropertyValueList([42])
    lst.reverse() # 1.54μs -> 1.44μs (6.58% faster)

def test_reverse_empty_list():
    # Test reversing an empty list
    lst = PropertyValueList([])
    lst.reverse() # 1.59μs -> 1.35μs (17.9% faster)

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

def test_reverse_already_reversed():
    # Test reversing a list that is already reversed
    lst = PropertyValueList([3, 2, 1])
    lst.reverse() # 1.63μs -> 1.41μs (15.7% faster)

def test_reverse_nested_lists():
    # Test reversing a list containing other lists
    lst = PropertyValueList([[1, 2], [3, 4], [5, 6]])
    lst.reverse() # 1.48μs -> 1.33μs (11.7% faster)

def test_reverse_with_none_values():
    # Test reversing a list with None values
    lst = PropertyValueList([None, 1, None, 2])
    lst.reverse() # 1.59μs -> 1.30μs (22.2% faster)

def test_reverse_boolean_values():
    # Test reversing a list of boolean values
    lst = PropertyValueList([True, False, True])
    lst.reverse() # 1.55μs -> 1.35μs (14.5% faster)

def test_reverse_tuple_elements():
    # Test reversing a list of tuples
    lst = PropertyValueList([(1, 2), (3, 4), (5, 6)])
    lst.reverse() # 1.56μs -> 1.36μs (14.8% faster)

def test_reverse_object_elements():
    # Test reversing a list of custom objects
    class Dummy:
        def __init__(self, v): self.v = v
        def __eq__(self, other): return isinstance(other, Dummy) and self.v == other.v
    lst = PropertyValueList([Dummy(1), Dummy(2), Dummy(3)])
    lst.reverse() # 1.59μs -> 1.50μs (5.87% faster)

def test_reverse_list_with_repeated_reversals():
    # Test reversing a list multiple times returns to original order
    orig = [1, 2, 3, 4]
    lst = PropertyValueList(orig)
    lst.reverse() # 1.55μs -> 1.39μs (11.1% faster)
    lst.reverse() # 586ns -> 639ns (8.29% slower)

def test_reverse_list_with_mutation_after_reverse():
    # Test mutation after reverse does not affect reverse behavior
    lst = PropertyValueList([1, 2, 3])
    lst.reverse() # 1.57μs -> 1.36μs (15.6% faster)
    lst.append(4)

def test_reverse_list_with_slice_assignment():
    # Test reverse after slice assignment
    lst = PropertyValueList([1, 2, 3, 4])
    lst[1:3] = [9, 8]
    lst.reverse() # 1.10μs -> 1.18μs (6.60% slower)

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

def test_reverse_large_list():
    # Test reversing a large list of integers
    orig = list(range(1000))
    lst = PropertyValueList(orig)
    lst.reverse() # 4.47μs -> 1.45μs (209% faster)

def test_reverse_large_list_of_strings():
    # Test reversing a large list of strings
    orig = [str(i) for i in range(1000)]
    lst = PropertyValueList(orig)
    lst.reverse() # 5.00μs -> 1.47μs (240% faster)

def test_reverse_large_list_of_tuples():
    # Test reversing a large list of tuples
    orig = [(i, i+1) for i in range(1000)]
    lst = PropertyValueList(orig)
    lst.reverse() # 5.10μs -> 1.57μs (225% faster)

def test_reverse_large_list_with_repeated_patterns():
    # Test reversing a large list with repeated patterns
    orig = [i % 10 for i in range(1000)]
    lst = PropertyValueList(orig)
    lst.reverse() # 4.32μs -> 1.57μs (175% faster)

def test_reverse_large_list_multiple_times():
    # Test reversing a large list multiple times
    orig = list(range(1000))
    lst = PropertyValueList(orig)
    lst.reverse() # 4.45μs -> 1.58μs (181% faster)
    lst.reverse() # 3.25μs -> 638ns (410% faster)

# --------------------- Additional Edge Cases ---------------------

def test_reverse_list_with_all_same_element():
    # Test reversing a list with all identical elements
    lst = PropertyValueList([7] * 10)
    lst.reverse() # 1.68μs -> 1.45μs (15.8% faster)

def test_reverse_list_with_boolean_and_none():
    # Test reversing a list with booleans and None
    lst = PropertyValueList([True, None, False, None, True])
    lst.reverse() # 1.59μs -> 1.43μs (11.9% faster)

def test_reverse_list_with_custom_equality():
    # Test reversing a list with objects that have custom equality
    class Weird:
        def __eq__(self, other): return True
    lst = PropertyValueList([Weird(), Weird()])
    lst.reverse() # 1.60μs -> 1.41μs (13.1% faster)

def test_reverse_list_with_large_nested_lists():
    # Test reversing a list of large nested lists
    orig = [[i for i in range(10)] for _ in range(100)]
    lst = PropertyValueList(orig)
    lst.reverse() # 2.11μs -> 1.55μs (36.0% faster)

def test_reverse_list_with_empty_inner_lists():
    # Test reversing a list with empty inner lists
    lst = PropertyValueList([[], [], []])
    lst.reverse() # 1.63μs -> 1.47μs (10.6% 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-PropertyValueList.reverse-mhwz0lc5 and push.