⚡️ Speed up function _is_viewable_list by 31%

[codeflash-ai]

📄 31% (0.31x) speedup for _is_viewable_list in panel/viewable.py

⏱️ Runtime : 74.6 microseconds → 57.1 microseconds (best of 17 runs)

📝 Explanation and details

Optimizations made:

• Use type(item_type) is tuple instead of isinstance for a faster type check.
• Store param_list.item_type to a local variable to avoid repeated attribute lookup.
• Replace generator expression in all() with an explicit for-loop, which is faster due to avoiding the overhead of a generator and function call.
• Behavioral preservation and code style are strictly maintained as requested.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from panel.viewable import _is_viewable_list


# Mock Viewable base class for testing
class Viewable:
    pass

# Mock classes for testing
class MyViewable(Viewable):
    pass

class NotViewable:
    pass

class AnotherViewable(Viewable):
    pass

# Mock param.List class for testing
class MockParamList:
    def __init__(self, item_type):
        self.item_type = item_type
from panel.viewable import _is_viewable_list

# unit tests

# 1. Basic Test Cases

def test_single_viewable_type():
    # Should return True for a single Viewable subclass
    param_list = MockParamList(MyViewable)
    codeflash_output = _is_viewable_list(param_list) # 2.27μs -> 2.59μs (12.2% slower)

def test_single_not_viewable_type():
    # Should return False for a single non-Viewable class
    param_list = MockParamList(NotViewable)
    codeflash_output = _is_viewable_list(param_list) # 1.36μs -> 1.40μs (3.00% slower)

def test_tuple_all_viewable_types():
    # Should return True for a tuple of only Viewable subclasses
    param_list = MockParamList((MyViewable, AnotherViewable))
    codeflash_output = _is_viewable_list(param_list) # 2.88μs -> 1.80μs (60.1% faster)

def test_tuple_mixed_types():
    # Should return False if any type in tuple is not a Viewable subclass
    param_list = MockParamList((MyViewable, NotViewable))
    codeflash_output = _is_viewable_list(param_list) # 2.38μs -> 1.60μs (48.2% faster)

def test_tuple_all_not_viewable():
    # Should return False for a tuple of only non-Viewable classes
    param_list = MockParamList((NotViewable, NotViewable))
    codeflash_output = _is_viewable_list(param_list) # 2.28μs -> 1.49μs (53.3% faster)

# 2. Edge Test Cases

def test_item_type_none():
    # Should return False if item_type is None
    param_list = MockParamList(None)
    codeflash_output = _is_viewable_list(param_list) # 500ns -> 564ns (11.3% slower)

def test_item_type_empty_tuple():
    # Should return True (vacuously) for empty tuple (all() of empty iterable is True)
    param_list = MockParamList(())
    codeflash_output = _is_viewable_list(param_list) # 469ns -> 561ns (16.4% slower)


def test_item_type_non_type_object():
    # Should raise TypeError if item_type is not a type or tuple of types
    param_list = MockParamList("not_a_type")
    with pytest.raises(TypeError):
        _is_viewable_list(param_list) # 2.41μs -> 2.94μs (18.1% slower)



def test_item_type_tuple_with_base_class():
    # Should return True if Viewable itself is in tuple
    param_list = MockParamList((Viewable, MyViewable))
    codeflash_output = _is_viewable_list(param_list) # 2.58μs -> 1.75μs (47.6% faster)

def test_item_type_is_base_class():
    # Should return True if item_type is Viewable itself
    param_list = MockParamList(Viewable)
    codeflash_output = _is_viewable_list(param_list) # 1.41μs -> 1.37μs (2.62% faster)

def test_item_type_tuple_with_builtin_type():
    # Should return False if tuple contains a builtin type (not subclass of Viewable)
    param_list = MockParamList((MyViewable, int))
    codeflash_output = _is_viewable_list(param_list) # 2.39μs -> 1.60μs (49.4% faster)

# 3. Large Scale Test Cases

def test_large_tuple_all_viewable():
    # Should return True for large tuple of Viewable subclasses
    class LargeViewable(Viewable): pass
    param_list = MockParamList(tuple(LargeViewable for _ in range(1000)))
    codeflash_output = _is_viewable_list(param_list) # 2.32μs -> 1.65μs (40.7% faster)

def test_large_tuple_one_not_viewable():
    # Should return False for large tuple with one non-Viewable class
    class LargeViewable(Viewable): pass
    types = [LargeViewable for _ in range(999)] + [NotViewable]
    param_list = MockParamList(tuple(types))
    codeflash_output = _is_viewable_list(param_list) # 2.23μs -> 1.65μs (34.9% faster)

def test_large_tuple_all_not_viewable():
    # Should return False for large tuple of non-Viewable classes
    param_list = MockParamList(tuple(NotViewable for _ in range(1000)))
    codeflash_output = _is_viewable_list(param_list) # 2.24μs -> 1.50μs (49.2% faster)



#------------------------------------------------
import pytest  # used for our unit tests
from panel.viewable import _is_viewable_list


# function to test
# Simulate the Viewable base class for testing
class Viewable:
    pass

# Simulate param.List for testing
class DummyParamList:
    def __init__(self, item_type=None):
        self.item_type = item_type
from panel.viewable import _is_viewable_list

# unit tests

# --- Basic Test Cases ---

def test_single_viewable_type():
    # Should return True for a single Viewable subclass
    class MyViewable(Viewable): pass
    param_list = DummyParamList(item_type=MyViewable)
    codeflash_output = _is_viewable_list(param_list) # 2.67μs -> 2.59μs (3.16% faster)

def test_single_non_viewable_type():
    # Should return False for a single non-Viewable class
    class NotViewable: pass
    param_list = DummyParamList(item_type=NotViewable)
    codeflash_output = _is_viewable_list(param_list) # 1.41μs -> 1.48μs (4.47% slower)

def test_none_item_type():
    # Should return False if item_type is None
    param_list = DummyParamList(item_type=None)
    codeflash_output = _is_viewable_list(param_list) # 548ns -> 641ns (14.5% slower)

def test_tuple_of_viewable_types():
    # Should return True for a tuple of Viewable subclasses
    class V1(Viewable): pass
    class V2(Viewable): pass
    param_list = DummyParamList(item_type=(V1, V2))
    codeflash_output = _is_viewable_list(param_list) # 3.02μs -> 1.69μs (79.1% faster)

def test_tuple_with_non_viewable_type():
    # Should return False if any type in tuple is not Viewable
    class V1(Viewable): pass
    class NV: pass
    param_list = DummyParamList(item_type=(V1, NV))
    codeflash_output = _is_viewable_list(param_list) # 2.35μs -> 1.69μs (39.4% faster)

def test_tuple_all_non_viewable_types():
    # Should return False for tuple of all non-Viewable types
    class NV1: pass
    class NV2: pass
    param_list = DummyParamList(item_type=(NV1, NV2))
    codeflash_output = _is_viewable_list(param_list) # 2.21μs -> 1.67μs (32.6% faster)

# --- Edge Test Cases ---

def test_empty_tuple_item_type():
    # Should return True for empty tuple, since all([]) == True
    param_list = DummyParamList(item_type=())
    codeflash_output = _is_viewable_list(param_list) # 532ns -> 490ns (8.57% faster)

def test_tuple_with_builtin_types():
    # Should return False if tuple contains built-in types
    param_list = DummyParamList(item_type=(int, str))
    codeflash_output = _is_viewable_list(param_list) # 2.31μs -> 1.70μs (36.0% faster)

def test_item_type_is_not_type_nor_tuple():
    # Should raise TypeError if item_type is not a type or tuple
    param_list = DummyParamList(item_type=123)
    with pytest.raises(TypeError):
        _is_viewable_list(param_list) # 2.54μs -> 2.38μs (6.71% faster)


def test_item_type_is_tuple_with_mixed_types():
    # Should return False if tuple contains Viewable and non-Viewable types
    class V1(Viewable): pass
    param_list = DummyParamList(item_type=(V1, str))
    codeflash_output = _is_viewable_list(param_list) # 2.55μs -> 1.92μs (33.3% faster)

def test_item_type_is_tuple_with_viewable_and_builtin():
    # Should return False if tuple contains Viewable and built-in type
    class V1(Viewable): pass
    param_list = DummyParamList(item_type=(V1, int))
    codeflash_output = _is_viewable_list(param_list) # 2.27μs -> 1.65μs (38.0% faster)


def test_item_type_is_tuple_with_viewable_and_object():
    # Should return False if tuple contains Viewable and object
    class V1(Viewable): pass
    param_list = DummyParamList(item_type=(V1, object))
    codeflash_output = _is_viewable_list(param_list) # 2.51μs -> 2.02μs (24.6% faster)

def test_item_type_is_tuple_with_duplicate_types():
    # Should return True if all are Viewable, even if duplicated
    class V1(Viewable): pass
    param_list = DummyParamList(item_type=(V1, V1))
    codeflash_output = _is_viewable_list(param_list) # 2.23μs -> 1.62μs (37.2% faster)

def test_item_type_is_tuple_with_subclass_and_base():
    # Should return True if all are subclasses of Viewable
    class V1(Viewable): pass
    param_list = DummyParamList(item_type=(Viewable, V1))
    codeflash_output = _is_viewable_list(param_list) # 2.32μs -> 1.49μs (56.0% faster)

# --- Large Scale Test Cases ---

def test_large_tuple_all_viewable():
    # Should return True for large tuple of Viewable subclasses
    classes = tuple(type(f'V{i}', (Viewable,), {}) for i in range(500))
    param_list = DummyParamList(item_type=classes)
    codeflash_output = _is_viewable_list(param_list) # 3.54μs -> 2.45μs (44.8% faster)

def test_large_tuple_one_non_viewable():
    # Should return False if one non-Viewable in large tuple
    classes = [type(f'V{i}', (Viewable,), {}) for i in range(499)]
    classes.append(int)  # Non-Viewable
    param_list = DummyParamList(item_type=tuple(classes))
    codeflash_output = _is_viewable_list(param_list) # 3.35μs -> 2.15μs (55.7% faster)

def test_large_tuple_all_non_viewable():
    # Should return False for large tuple of non-Viewable classes
    classes = tuple(type(f'NV{i}', (), {}) for i in range(500))
    param_list = DummyParamList(item_type=classes)
    codeflash_output = _is_viewable_list(param_list) # 3.73μs -> 2.40μs (55.4% faster)

def test_large_tuple_mixed_types():
    # Should return False if half Viewable, half non-Viewable
    classes = []
    for i in range(250):
        classes.append(type(f'V{i}', (Viewable,), {}))
        classes.append(type(f'NV{i}', (), {}))
    param_list = DummyParamList(item_type=tuple(classes))
    codeflash_output = _is_viewable_list(param_list) # 3.44μs -> 2.40μs (43.6% faster)

def test_large_tuple_with_builtin_types():
    # Should return False if tuple contains built-in types among Viewable
    classes = [type(f'V{i}', (Viewable,), {}) for i in range(499)]
    classes.append(str)  # Non-Viewable
    param_list = DummyParamList(item_type=tuple(classes))
    codeflash_output = _is_viewable_list(param_list) # 3.31μs -> 2.22μs (49.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 panel.viewable import Children
from panel.viewable import _is_viewable_list
import pytest

def test__is_viewable_list():
    with pytest.raises(TypeError):
        _is_viewable_list(Children(default=[], instantiate='', bounds=0, item_type=2, class_=0, doc='', label='', precedence='', constant=0, readonly=0, pickle_default_value='', allow_None='\x00', per_instance=0, allow_refs=0, nested_refs=''))

def test__is_viewable_list_2():
    _is_viewable_list(Children(default=[], instantiate=0, bounds=0, item_type=(), class_='', doc=0, label='', precedence=0, constant=0, readonly=0, pickle_default_value=0, allow_None=0, per_instance=0, allow_refs=0, nested_refs=0))

To edit these changes git checkout codeflash/optimize-_is_viewable_list-mha0zhph and push.