⚡️ Speed up function get_watchers by 40%

[codeflash-ai]

📄 40% (0.40x) speedup for get_watchers in panel/io/embed.py

⏱️ Runtime : 192 microseconds → 137 microseconds (best of 67 runs)

📝 Explanation and details

The optimization replaces a nested list comprehension with explicit loops and pre-cached method lookups, achieving a 40% speedup.

Key optimizations:

1. Eliminated intermediate list creation: The original list comprehension [w for pwatchers in ... for awatchers in ... for w in awatchers] creates multiple intermediate lists during flattening. The optimized version uses extend() to append lists directly to the result, avoiding temporary allocations.

2. Pre-cached method lookup: extend = watchers.extend moves the method lookup outside the loops, eliminating repeated attribute access overhead during each iteration.

3. More efficient memory usage: Instead of building nested intermediate lists and then flattening them, the optimized version builds the final result incrementally.

Performance characteristics by test case:

• Small structures (1-5 watchers): 10-25% improvement due to reduced overhead
• Medium structures (multiple params/actions): 15-30% improvement from avoiding intermediate allocations
• Large structures (100+ params, 1000+ watchers): 60-450% improvement where memory allocation overhead dominates

The optimization is particularly effective for the common use case of flattening nested collections, especially when the inner collections (watcher lists) are non-empty, as shown by the dramatic 452% speedup in the single-action-many-watchers test case.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from panel.io.embed import get_watchers


# Helper class to simulate the structure expected by get_watchers
class DummyReactive:
    class Param:
        def __init__(self, watchers):
            self.watchers = watchers
    def __init__(self, watchers):
        self.param = DummyReactive.Param(watchers)

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

def test_empty_watchers_returns_empty_list():
    # No watchers at all
    reactive = DummyReactive({})
    codeflash_output = get_watchers(reactive) # 1.06μs -> 944ns (11.9% faster)

def test_single_watcher_single_param_single_action():
    # One param, one action, one watcher
    watcher = object()
    watchers = {'param1': {'action1': [watcher]}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.25μs -> 1.10μs (13.3% faster)

def test_multiple_watchers_single_param_single_action():
    # One param, one action, multiple watchers
    watcher1 = object()
    watcher2 = object()
    watchers = {'param1': {'action1': [watcher1, watcher2]}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.30μs -> 1.04μs (24.5% faster)

def test_multiple_watchers_single_param_multiple_actions():
    # One param, multiple actions, multiple watchers
    watcher1 = object()
    watcher2 = object()
    watcher3 = object()
    watchers = {'param1': {'action1': [watcher1], 'action2': [watcher2, watcher3]}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.39μs -> 1.18μs (18.3% faster)

def test_multiple_params_multiple_actions_multiple_watchers():
    # Multiple params, multiple actions, multiple watchers
    watcher1 = object()
    watcher2 = object()
    watcher3 = object()
    watcher4 = object()
    watchers = {
        'param1': {'action1': [watcher1], 'action2': [watcher2]},
        'param2': {'action1': [watcher3, watcher4]}
    }
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.54μs -> 1.36μs (13.0% faster)

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

def test_param_with_no_actions():
    # Param exists but has no actions (empty dict)
    watchers = {'param1': {}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.18μs -> 985ns (19.3% faster)

def test_action_with_empty_watcher_list():
    # Param/action exists but watcher list is empty
    watchers = {'param1': {'action1': []}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.19μs -> 1.07μs (11.5% faster)

def test_mix_of_empty_and_nonempty_watchers():
    # Some actions have watchers, some don't
    watcher1 = object()
    watchers = {
        'param1': {'action1': [], 'action2': [watcher1]},
        'param2': {'action1': []}
    }
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.49μs -> 1.25μs (19.0% faster)

def test_param_with_none_action_dict():
    # Param maps to None instead of dict (should raise AttributeError)
    watchers = {'param1': None}
    reactive = DummyReactive(watchers)
    with pytest.raises(AttributeError):
        get_watchers(reactive) # 2.02μs -> 1.78μs (13.6% faster)

def test_action_with_none_watcher_list():
    # Action maps to None instead of list (should raise TypeError)
    watchers = {'param1': {'action1': None}}
    reactive = DummyReactive(watchers)
    with pytest.raises(TypeError):
        get_watchers(reactive) # 1.93μs -> 1.72μs (12.2% faster)

def test_non_string_param_and_action_names():
    # Param and action names are not strings
    watcher1 = object()
    watcher2 = object()
    watchers = {
        123: {456: [watcher1]},
        (1, 2): {(3, 4): [watcher2]}
    }
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.59μs -> 1.27μs (24.8% faster)

def test_duplicate_watchers_in_different_places():
    # Same watcher object appears in multiple places
    watcher = object()
    watchers = {
        'param1': {'action1': [watcher]},
        'param2': {'action2': [watcher]}
    }
    reactive = DummyReactive(watchers)
    # Both instances should be present
    codeflash_output = get_watchers(reactive) # 1.39μs -> 1.16μs (20.0% faster)

def test_watcher_is_none():
    # Watcher list contains None
    watchers = {'param1': {'action1': [None]}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.24μs -> 1.07μs (15.9% faster)

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

def test_large_number_of_params_and_actions():
    # 100 params, each with 10 actions, each with 2 watchers
    num_params = 100
    num_actions = 10
    num_watchers = 2
    watchers = {}
    watcher_objs = []
    for p in range(num_params):
        param_name = f'param{p}'
        watchers[param_name] = {}
        for a in range(num_actions):
            action_name = f'action{a}'
            # Each watcher is a unique object
            w1 = object()
            w2 = object()
            watcher_objs.extend([w1, w2])
            watchers[param_name][action_name] = [w1, w2]
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive); result = codeflash_output # 45.5μs -> 27.8μs (63.3% faster)

def test_large_number_of_empty_params():
    # 500 params, all with empty action dicts
    watchers = {f'param{i}': {} for i in range(500)}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 19.5μs -> 18.9μs (2.99% faster)

def test_large_number_of_actions_some_empty():
    # 50 params, each with 20 actions, half have watchers
    num_params = 50
    num_actions = 20
    watcher_objs = []
    watchers = {}
    for p in range(num_params):
        param_name = f'param{p}'
        watchers[param_name] = {}
        for a in range(num_actions):
            action_name = f'action{a}'
            if a % 2 == 0:
                # Even actions have watchers
                w = object()
                watcher_objs.append(w)
                watchers[param_name][action_name] = [w]
            else:
                # Odd actions are empty
                watchers[param_name][action_name] = []
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive); result = codeflash_output # 28.9μs -> 22.0μs (31.5% faster)

def test_large_single_action_many_watchers():
    # Single param, single action, 1000 watchers
    watchers_list = [object() for _ in range(1000)]
    watchers = {'param1': {'action1': watchers_list}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive); result = codeflash_output # 11.8μs -> 2.13μs (452% 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 panel.io.embed import get_watchers


# Helper class for mocking the structure expected by get_watchers
class DummyReactive:
    class DummyParam:
        def __init__(self, watchers):
            self.watchers = watchers
    def __init__(self, watchers):
        self.param = self.DummyParam(watchers)

# Unit tests

# 1. BASIC TEST CASES

def test_empty_watchers():
    # Test with completely empty watchers dict
    reactive = DummyReactive({})
    codeflash_output = get_watchers(reactive) # 1.16μs -> 926ns (24.7% faster)

def test_single_watcher():
    # Test with a single watcher in the structure
    watcher = object()
    watchers = {'x': {'y': [watcher]}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.25μs -> 1.14μs (9.92% faster)

def test_multiple_watchers_single_param():
    # Multiple watchers under one param/attribute
    watcher1 = object()
    watcher2 = object()
    watchers = {'param1': {'attr1': [watcher1, watcher2]}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.30μs -> 1.09μs (19.2% faster)

def test_multiple_params_and_attrs():
    # Multiple params and attributes, each with one watcher
    watcher_a = object()
    watcher_b = object()
    watcher_c = object()
    watchers = {
        'p1': {'a1': [watcher_a]},
        'p2': {'a2': [watcher_b], 'a3': [watcher_c]}
    }
    reactive = DummyReactive(watchers)
    # The order should be: [watcher_a, watcher_b, watcher_c]
    codeflash_output = get_watchers(reactive); result = codeflash_output # 1.60μs -> 1.38μs (16.2% faster)

def test_empty_lists_in_structure():
    # Watchers dict contains empty lists
    watchers = {'p1': {'a1': []}, 'p2': {'a2': []}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.38μs -> 1.21μs (14.3% faster)

# 2. EDGE TEST CASES

def test_missing_attributes():
    # Watchers dict contains params with no attributes (empty dicts)
    watchers = {'p1': {}, 'p2': {}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.29μs -> 1.01μs (27.7% faster)

def test_non_list_values():
    # Watchers dict contains non-list values (should not happen, but test robustness)
    watcher = object()
    watchers = {'p1': {'a1': watcher}}  # Not a list!
    reactive = DummyReactive(watchers)
    # Should raise TypeError since the function expects lists
    with pytest.raises(TypeError):
        get_watchers(reactive) # 1.89μs -> 1.75μs (8.08% faster)

def test_nested_empty_dicts():
    # Watchers dict contains nested empty dicts
    watchers = {'p1': {}, 'p2': {'a1': []}, 'p3': {}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.55μs -> 1.29μs (20.2% faster)

def test_duplicate_watchers():
    # Watchers dict contains the same watcher object in multiple places
    watcher = object()
    watchers = {'p1': {'a1': [watcher]}, 'p2': {'a2': [watcher]}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.49μs -> 1.30μs (14.5% faster)

def test_none_in_watcher_list():
    # Watchers dict contains None in watcher lists
    watcher = object()
    watchers = {'p1': {'a1': [watcher, None]}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.27μs -> 1.07μs (18.5% faster)

def test_non_string_param_and_attr_keys():
    # Param and attribute keys are not strings (e.g., integers, tuples)
    watcher1 = object()
    watcher2 = object()
    watchers = {1: {2: [watcher1]}, (3, 4): {(5, 6): [watcher2]}}
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.44μs -> 1.25μs (14.7% faster)

def test_order_preservation():
    # Ensure order is preserved: param order, then attr order, then watcher order
    watcher1 = object()
    watcher2 = object()
    watcher3 = object()
    watchers = {
        'p1': {'a1': [watcher1]},
        'p2': {'a2': [watcher2], 'a3': [watcher3]}
    }
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive) # 1.56μs -> 1.29μs (20.2% faster)

# 3. LARGE SCALE TEST CASES

def test_large_number_of_watchers():
    # Large number of params/attrs/watchers
    num_params = 50
    num_attrs = 10
    num_watchers = 2
    watchers = {}
    watcher_objs = []
    for p in range(num_params):
        attr_dict = {}
        for a in range(num_attrs):
            wlist = [object() for _ in range(num_watchers)]
            watcher_objs.extend(wlist)
            attr_dict[f'attr{a}'] = wlist
        watchers[f'param{p}'] = attr_dict
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive); result = codeflash_output # 25.7μs -> 15.5μs (65.9% faster)

def test_large_empty_structure():
    # Large structure with all empty lists
    num_params = 100
    num_attrs = 5
    watchers = {}
    for p in range(num_params):
        attr_dict = {}
        for a in range(num_attrs):
            attr_dict[f'attr{a}'] = []
        watchers[f'param{p}'] = attr_dict
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive); result = codeflash_output # 15.6μs -> 13.2μs (18.3% faster)

def test_large_mixed_structure():
    # Large structure with a mix of empty and non-empty lists
    num_params = 20
    num_attrs = 10
    watchers = {}
    watcher_objs = []
    for p in range(num_params):
        attr_dict = {}
        for a in range(num_attrs):
            if (p + a) % 3 == 0:
                wlist = [object(), object()]
                watcher_objs.extend(wlist)
                attr_dict[f'attr{a}'] = wlist
            else:
                attr_dict[f'attr{a}'] = []
        watchers[f'param{p}'] = attr_dict
    reactive = DummyReactive(watchers)
    codeflash_output = get_watchers(reactive); result = codeflash_output # 9.50μs -> 6.85μs (38.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-get_watchers-mhbwrgzl and push.