⚡️ Speed up function _use_widgets by 13%

[codeflash-ai]

📄 13% (0.13x) speedup for _use_widgets in src/bokeh/embed/bundle.py

⏱️ Runtime : 2.00 milliseconds → 1.77 milliseconds (best of 44 runs)

📝 Explanation and details

The optimization achieves a 12% speedup by replacing Python's built-in any() function with explicit for loops that enable early returns.

Key changes:

1. Eliminated generator overhead in _any(): Replaced any(query(x) for x in objs) with a direct for loop that returns True immediately upon finding a match. This avoids creating a generator object and the overhead of the any() builtin.

2. Direct widget checking in _use_widgets(): Instead of using the _any() helper with a lambda, the optimized version loops directly through objects and checks isinstance(obj, Widget), returning True on first match. This eliminates function call overhead and lambda creation.

3. Preserved import location: The Widget import remains inside the function (not moved outside as mentioned in comments), maintaining the original lazy import behavior.

Why this works:

• Early termination: Both loops exit immediately when a widget is found, avoiding unnecessary iterations
• Reduced function call overhead: Direct loops eliminate the cost of calling _any() and creating lambda functions
• Memory efficiency: No generator objects or intermediate data structures are created

Performance characteristics by test case:

• Small sets with widgets: 17-32% faster due to reduced overhead
• Large sets with early matches: 30-41% faster due to early termination
• Large sets with no matches: 13-18% faster from avoiding generator allocation
• Edge cases: Consistent 1-23% improvements across various scenarios

The optimization is most effective when widgets are found early in the iteration or when avoiding the overhead of any() and generators provides measurable benefit.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 19 Passed
🌀 Generated Regression Tests	✅ 44 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/embed/test_bundle.py::Test__use_widgets.test_with_widgets	28.9μs	21.8μs	32.9%✅
unit/bokeh/embed/test_bundle.py::Test__use_widgets.test_without_widgets	212μs	201μs	5.68%✅

🌀 Generated Regression Tests and Runtime

import pytest
from bokeh.embed.bundle import _use_widgets


# Dummy HasProps and Widget classes to simulate Bokeh's behavior for testing
class HasProps:
    """Simulates Bokeh's HasProps base class."""
    model_class_reverse_map = {}

    def __init__(self):
        # Simulate the __view_module__ attribute
        self.__view_module__ = "bokeh.models"
        # Simulate __implementation__ attribute (optional)
        self.__implementation__ = None

class Widget(HasProps):
    """Simulates Bokeh's Widget class."""
    pass

# Simulate a non-widget HasProps subclass
class NonWidget(HasProps):
    pass

# Simulate an extension widget (not in 'bokeh' module)
class ExtensionWidget(Widget):
    def __init__(self):
        super().__init__()
        self.__view_module__ = "my_ext.widgets"

# Simulate another extension non-widget
class ExtensionNonWidget(NonWidget):
    def __init__(self):
        super().__init__()
        self.__view_module__ = "my_ext.models"

# Patch HasProps.model_class_reverse_map for extension tests
def setup_model_class_reverse_map():
    # Simulate mapping from model names to classes
    HasProps.model_class_reverse_map = {
        "Widget": Widget,
        "NonWidget": NonWidget,
        "ExtensionWidget": ExtensionWidget,
        "ExtensionNonWidget": ExtensionNonWidget,
    }
from bokeh.embed.bundle import _use_widgets

# ---------------------- UNIT TESTS ----------------------

# BASIC TEST CASES

def test_empty_set_returns_false():
    """Test with an empty set: should return False (no widgets present)."""
    setup_model_class_reverse_map()
    codeflash_output = _use_widgets(set()) # 6.50μs -> 5.54μs (17.3% faster)

def test_single_widget_returns_true():
    """Test with a set containing a single Widget: should return True."""
    setup_model_class_reverse_map()
    w = Widget()
    codeflash_output = _use_widgets({w}) # 6.52μs -> 5.02μs (29.9% faster)

def test_single_nonwidget_returns_false():
    """Test with a set containing a single NonWidget: should return False."""
    setup_model_class_reverse_map()
    nw = NonWidget()
    codeflash_output = _use_widgets({nw}) # 5.94μs -> 4.70μs (26.4% faster)

def test_multiple_widgets_and_nonwidgets():
    """Test with a mix of Widget and NonWidget instances."""
    setup_model_class_reverse_map()
    w1 = Widget()
    w2 = Widget()
    nw1 = NonWidget()
    nw2 = NonWidget()
    codeflash_output = _use_widgets({w1, nw1, nw2}) # 6.45μs -> 5.20μs (24.1% faster)
    codeflash_output = _use_widgets({nw1, nw2}) # 2.65μs -> 2.22μs (19.3% faster)
    codeflash_output = _use_widgets({w1, w2}) # 2.20μs -> 1.94μs (13.4% faster)

def test_duplicate_widgets():
    """Test with duplicate Widget instances: should still return True."""
    setup_model_class_reverse_map()
    w = Widget()
    codeflash_output = _use_widgets({w, w}) # 5.38μs -> 4.65μs (15.7% faster)

# EDGE TEST CASES

def test_extension_widget_detected():
    """Test with an extension widget (not in 'bokeh' module): should return True."""
    setup_model_class_reverse_map()
    ew = ExtensionWidget()
    # Set __module__ to simulate extension
    ew.__module__ = "my_ext.widgets"
    codeflash_output = _use_widgets({ew}) # 5.58μs -> 4.64μs (20.2% faster)

def test_extension_nonwidget_not_detected():
    """Test with an extension non-widget: should return False."""
    setup_model_class_reverse_map()
    enw = ExtensionNonWidget()
    enw.__module__ = "my_ext.models"
    codeflash_output = _use_widgets({enw}) # 5.57μs -> 4.50μs (23.9% faster)

def test_mixed_extension_and_core_widgets():
    """Test with both core and extension widgets: should return True."""
    setup_model_class_reverse_map()
    w = Widget()
    ew = ExtensionWidget()
    ew.__module__ = "my_ext.widgets"
    codeflash_output = _use_widgets({w, ew}) # 6.11μs -> 4.61μs (32.6% faster)

def test_object_with_implementation_skipped():
    """Test that objects with __implementation__ attribute are skipped."""
    setup_model_class_reverse_map()
    w = Widget()
    nw = NonWidget()
    nw.__implementation__ = "dummy"
    codeflash_output = _use_widgets({w, nw}) # 5.86μs -> 4.92μs (19.0% faster)
    codeflash_output = _use_widgets({nw}) # 2.46μs -> 2.12μs (16.2% faster)

def test_object_with_missing_view_module():
    """Test object missing __view_module__ attribute."""
    setup_model_class_reverse_map()
    class OddObj(HasProps):
        pass
    o = OddObj()
    # Remove __view_module__ to simulate missing attribute
    del o.__view_module__
    # Should not raise, should return False
    codeflash_output = _use_widgets({o}) # 5.66μs -> 4.67μs (21.1% faster)

def test_object_with_nonstandard_view_module():
    """Test object with a non-standard __view_module__ value."""
    setup_model_class_reverse_map()
    class OddWidget(Widget):
        def __init__(self):
            super().__init__()
            self.__view_module__ = "custom.module"
    ow = OddWidget()
    codeflash_output = _use_widgets({ow}) # 5.48μs -> 4.76μs (15.1% faster)

def test_object_with_nonstring_view_module():
    """Test object with __view_module__ not a string."""
    setup_model_class_reverse_map()
    class OddWidget(Widget):
        def __init__(self):
            super().__init__()
            self.__view_module__ = 12345
    ow = OddWidget()
    # Should not raise, should still return True because it's a Widget instance
    codeflash_output = _use_widgets({ow}) # 5.64μs -> 4.78μs (18.0% faster)

def test_object_with_none_view_module():
    """Test object with __view_module__ as None."""
    setup_model_class_reverse_map()
    class OddWidget(Widget):
        def __init__(self):
            super().__init__()
            self.__view_module__ = None
    ow = OddWidget()
    codeflash_output = _use_widgets({ow}) # 5.66μs -> 4.78μs (18.4% faster)

def test_object_with_non_widget_but_widget_in_reverse_map():
    """Test object is not a Widget but Widget is present in model_class_reverse_map."""
    setup_model_class_reverse_map()
    nw = NonWidget()
    codeflash_output = _use_widgets({nw}) # 5.59μs -> 4.54μs (23.2% faster)

# LARGE SCALE TEST CASES

def test_large_set_of_nonwidgets():
    """Test with a large set of NonWidget instances: should return False."""
    setup_model_class_reverse_map()
    objs = {NonWidget() for _ in range(500)}
    codeflash_output = _use_widgets(objs) # 62.5μs -> 44.8μs (39.5% faster)

def test_large_set_with_one_widget():
    """Test with a large set containing one Widget: should return True."""
    setup_model_class_reverse_map()
    objs = {NonWidget() for _ in range(499)}
    w = Widget()
    objs.add(w)
    codeflash_output = _use_widgets(objs) # 62.6μs -> 44.4μs (41.1% faster)

def test_large_set_of_widgets():
    """Test with a large set of Widget instances: should return True."""
    setup_model_class_reverse_map()
    objs = {Widget() for _ in range(500)}
    codeflash_output = _use_widgets(objs) # 62.9μs -> 48.1μs (30.8% faster)

def test_large_set_with_extension_widget():
    """Test with a large set including one extension widget: should return True."""
    setup_model_class_reverse_map()
    objs = {NonWidget() for _ in range(499)}
    ew = ExtensionWidget()
    ew.__module__ = "my_ext.widgets"
    objs.add(ew)
    codeflash_output = _use_widgets(objs) # 63.2μs -> 48.1μs (31.5% faster)

def test_large_set_mixed_widgets_and_extension_widgets():
    """Test with a large set of core widgets and extension widgets."""
    setup_model_class_reverse_map()
    objs = {Widget() for _ in range(250)}
    objs.update({ExtensionWidget() for _ in range(250)})
    for obj in objs:
        if isinstance(obj, ExtensionWidget):
            obj.__module__ = "my_ext.widgets"
    codeflash_output = _use_widgets(objs) # 66.4μs -> 48.1μs (38.1% faster)

def test_large_set_with_duplicate_widgets():
    """Test with a large set containing duplicate Widget instances."""
    setup_model_class_reverse_map()
    w = Widget()
    objs = {w for _ in range(500)}
    # Only one unique widget, but should still return True
    codeflash_output = _use_widgets(objs) # 6.21μs -> 4.97μs (24.9% 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  # used for our unit tests
from bokeh.embed.bundle import _use_widgets


# Mocks and helpers for Bokeh's HasProps and Widget
class HasProps:
    # Simulate Bokeh's HasProps base class
    model_class_reverse_map = {}

    def __init__(self):
        # Simulate what Bokeh objects might have
        self.__view_module__ = "bokeh.models"
        # Optionally, some objects may have __implementation__ attribute
        # which signals custom JS implementation

# Simulate Bokeh's Widget base class
class Widget(HasProps):
    pass

# Simulate a non-widget HasProps subclass
class NonWidget(HasProps):
    pass

# Simulate a third-party widget
class ThirdPartyWidget(Widget):
    pass

# Simulate a third-party HasProps subclass (not a widget)
class ThirdPartyNonWidget(HasProps):
    pass

# Simulate a HasProps subclass with __implementation__ attribute
class CustomImplWidget(Widget):
    __implementation__ = True

# Simulate a HasProps subclass with a different __view_module__
class ExternalWidget(Widget):
    def __init__(self):
        super().__init__()
        self.__view_module__ = "external.widgets"

class ExternalNonWidget(HasProps):
    def __init__(self):
        super().__init__()
        self.__view_module__ = "external.models"

# Patch HasProps.model_class_reverse_map to simulate Bokeh's registry
def reset_model_class_reverse_map():
    HasProps.model_class_reverse_map = {
        "Widget": Widget,
        "NonWidget": NonWidget,
        "ThirdPartyWidget": ThirdPartyWidget,
        "ThirdPartyNonWidget": ThirdPartyNonWidget,
        "CustomImplWidget": CustomImplWidget,
        "ExternalWidget": ExternalWidget,
        "ExternalNonWidget": ExternalNonWidget,
    }
from bokeh.embed.bundle import _use_widgets

# unit tests

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

def test_empty_set_returns_false():
    """Test that an empty set returns False (no widgets present)."""
    reset_model_class_reverse_map()
    codeflash_output = _use_widgets(set()) # 5.97μs -> 4.89μs (22.2% faster)

def test_single_widget_returns_true():
    """Test that a set with a single Widget returns True."""
    reset_model_class_reverse_map()
    w = Widget()
    codeflash_output = _use_widgets({w}) # 6.71μs -> 5.74μs (17.0% faster)

def test_single_nonwidget_returns_false():
    """Test that a set with a single non-Widget returns False."""
    reset_model_class_reverse_map()
    nw = NonWidget()
    codeflash_output = _use_widgets({nw}) # 6.09μs -> 5.45μs (11.7% faster)

def test_mixed_widgets_and_nonwidgets_returns_true():
    """Test that a set with both Widget and non-Widget returns True."""
    reset_model_class_reverse_map()
    w = Widget()
    nw = NonWidget()
    codeflash_output = _use_widgets({w, nw}) # 6.89μs -> 5.63μs (22.4% faster)

def test_multiple_nonwidgets_returns_false():
    """Test that a set with only non-Widgets returns False."""
    reset_model_class_reverse_map()
    nw1 = NonWidget()
    nw2 = NonWidget()
    codeflash_output = _use_widgets({nw1, nw2}) # 6.91μs -> 5.56μs (24.2% faster)

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

def test_widget_with_custom_implementation_skipped():
    """Test that widgets with __implementation__ are skipped by _query_extensions."""
    reset_model_class_reverse_map()
    w = CustomImplWidget()
    # Should be detected by _any, not by _query_extensions
    codeflash_output = _use_widgets({w}) # 5.80μs -> 4.90μs (18.4% faster)

def test_external_widget_detected_by_query_extensions():
    """Test that an external widget (not in bokeh module) is detected."""
    reset_model_class_reverse_map()
    ew = ExternalWidget()
    codeflash_output = _use_widgets({ew}) # 99.5μs -> 97.9μs (1.56% faster)

def test_external_nonwidget_not_detected():
    """Test that an external non-widget is not detected."""
    reset_model_class_reverse_map()
    enw = ExternalNonWidget()
    codeflash_output = _use_widgets({enw}) # 58.1μs -> 57.4μs (1.20% faster)

def test_third_party_widget_detected():
    """Test that a third-party widget is detected."""
    reset_model_class_reverse_map()
    tpw = ThirdPartyWidget()
    tpw.__view_module__ = "thirdparty.widgets"
    codeflash_output = _use_widgets({tpw}) # 53.5μs -> 52.5μs (1.94% faster)

def test_third_party_nonwidget_not_detected():
    """Test that a third-party non-widget is not detected."""
    reset_model_class_reverse_map()
    tpnw = ThirdPartyNonWidget()
    tpnw.__view_module__ = "thirdparty.models"
    codeflash_output = _use_widgets({tpnw}) # 52.4μs -> 52.6μs (0.481% slower)

def test_duplicate_external_module_names_only_checked_once():
    """Test that duplicate external module names are only checked once."""
    reset_model_class_reverse_map()
    ew1 = ExternalWidget()
    ew2 = ExternalWidget()
    ew1.__view_module__ = "external.widgets"
    ew2.__view_module__ = "external.widgets"
    codeflash_output = _use_widgets({ew1, ew2}) # 53.5μs -> 51.9μs (3.09% faster)



def test_object_with_empty_view_module_string():
    """Test that objects with an empty __view_module__ string are handled gracefully."""
    reset_model_class_reverse_map()
    class EmptyViewModule(HasProps):
        def __init__(self):
            super().__init__()
            self.__view_module__ = ""
    evm = EmptyViewModule()
    codeflash_output = _use_widgets({evm}) # 109μs -> 107μs (1.63% faster)

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

def test_large_set_of_nonwidgets_returns_false():
    """Test that a large set of non-Widgets returns False efficiently."""
    reset_model_class_reverse_map()
    objs = {NonWidget() for _ in range(500)}
    codeflash_output = _use_widgets(objs) # 103μs -> 87.2μs (18.5% faster)

def test_large_set_with_one_widget_returns_true():
    """Test that a large set with one Widget returns True efficiently."""
    reset_model_class_reverse_map()
    objs = {NonWidget() for _ in range(499)}
    w = Widget()
    objs.add(w)
    codeflash_output = _use_widgets(objs) # 100μs -> 85.3μs (17.9% faster)

def test_large_set_of_external_widgets_returns_true():
    """Test that a large set of external widgets is detected efficiently."""
    reset_model_class_reverse_map()
    objs = set()
    for _ in range(500):
        ew = ExternalWidget()
        ew.__view_module__ = "external.widgets"
        objs.add(ew)
    codeflash_output = _use_widgets(objs) # 181μs -> 160μs (13.1% faster)

def test_large_mixed_set_with_no_widgets_returns_false():
    """Test that a large mixed set with no widgets returns False."""
    reset_model_class_reverse_map()
    objs = set()
    for i in range(250):
        nw = NonWidget()
        nw.__view_module__ = "bokeh.models"
        objs.add(nw)
        enw = ExternalNonWidget()
        enw.__view_module__ = "external.models"
        objs.add(enw)
    codeflash_output = _use_widgets(objs) # 170μs -> 150μs (13.0% faster)

def test_large_mixed_set_with_external_and_bokeh_widgets_returns_true():
    """Test that a large mixed set with both bokeh and external widgets returns True."""
    reset_model_class_reverse_map()
    objs = set()
    for i in range(200):
        nw = NonWidget()
        objs.add(nw)
        ew = ExternalWidget()
        ew.__view_module__ = "external.widgets"
        objs.add(ew)
    for i in range(100):
        w = Widget()
        objs.add(w)
    codeflash_output = _use_widgets(objs) # 169μs -> 148μs (14.0% faster)

# ----------------- Determinism Test Case -----------------

def test_determinism_of_results():
    """Test that repeated calls with the same set yield the same result."""
    reset_model_class_reverse_map()
    objs = {Widget(), NonWidget(), ExternalWidget()}
    codeflash_output = _use_widgets(objs); result1 = codeflash_output # 59.8μs -> 58.9μs (1.46% faster)
    codeflash_output = _use_widgets(objs); result2 = codeflash_output # 31.1μs -> 31.0μs (0.351% faster)

# ----------------- Mutant Detection Test Case -----------------

def test_mutant_detection_widget_type_check():
    """Test that changing isinstance to issubclass in _use_widgets would break detection."""
    reset_model_class_reverse_map()
    class FakeWidget(HasProps):
        pass
    fw = FakeWidget()
    # Should not be detected as a Widget
    codeflash_output = _use_widgets({fw}) # 6.46μs -> 5.72μs (13.0% faster)

def test_mutant_detection_ext_use_widgets_logic():
    """Test that removing _ext_use_widgets from _use_widgets would break detection of external widgets."""
    reset_model_class_reverse_map()
    ew = ExternalWidget()
    ew.__view_module__ = "external.widgets"
    # Should be detected as a widget via _ext_use_widgets
    codeflash_output = _use_widgets({ew}) # 61.7μs -> 59.5μs (3.74% 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-_use_widgets-mhb6o9b3 and push.