⚡️ Speed up function _is_viewable_class_selector by 28%

[codeflash-ai]

📄 28% (0.28x) speedup for _is_viewable_class_selector in panel/viewable.py

⏱️ Runtime : 42.4 microseconds → 33.2 microseconds (best of 15 runs)

📝 Explanation and details

The optimized code achieves a 27% speedup by eliminating redundant attribute access and replacing Python's built-in all() with a manual loop for tuple processing.

Key optimizations:

1. Cached attribute access: class_ = class_selector.class_ at the start eliminates repeated .class_ lookups that were happening in both the original's condition checks and tuple iteration.

2. Manual loop replaces all(): For tuple cases, the original used all(issubclass(cls, Viewable) for cls in class_selector.class_) which creates a generator and calls the built-in all() function. The optimized version uses a direct for loop with early return, avoiding the generator overhead and function call.

3. Local variable caching: viewable = Viewable caches the class reference, reducing global name lookups during the loop iterations.

4. Inverted isinstance check: Changed isinstance(class_, tuple) to if not isinstance(class_, tuple) to handle the more common single-class case first.

Performance impact by test case:

• Tuple cases show the biggest gains (46-66% faster): The manual loop significantly outperforms all() with generators
• Large tuple tests (500 classes) see 47-57% improvements, demonstrating the optimization scales well
• Simple cases may be slightly slower due to the extra variable assignment, but this is negligible compared to the gains on tuple cases

The optimization is particularly effective for scenarios with tuple class selectors, which appear to be common in the codebase based on the test coverage.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import param
# imports
import pytest  # used for our unit tests
from panel.viewable import _is_viewable_class_selector


# Minimal Viewable base class for testing
class Viewable:
    pass

# Some dummy classes for testing
class A(Viewable):
    pass

class B(Viewable):
    pass

class C:
    pass

class D:
    pass
from panel.viewable import _is_viewable_class_selector


# Helper to create a param.ClassSelector with a given class_ value
def make_selector(class_):
    # param.ClassSelector requires a name and class_
    return param.ClassSelector(class_, name="dummy")

# unit tests

# --- Basic Test Cases ---






















#------------------------------------------------
import types

# imports
import pytest
from panel.viewable import _is_viewable_class_selector


# Minimal stub for param.ClassSelector, since we can't import param in this context
class DummyClassSelector:
    def __init__(self, class_):
        self.class_ = class_

# Minimal stub for Viewable base class
class Viewable:
    pass

# Some subclasses for testing
class MyViewable(Viewable):
    pass

class AnotherViewable(Viewable):
    pass

class NotViewable:
    pass
from panel.viewable import _is_viewable_class_selector

# unit tests

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


def test_single_viewable_base_class():
    # Should return True for Viewable itself
    cs = DummyClassSelector(Viewable)
    codeflash_output = _is_viewable_class_selector(cs) # 1.25μs -> 1.26μs (1.11% slower)



def test_tuple_mixed_viewable_and_non_viewable():
    # Should return False if any class in tuple is not a Viewable
    cs = DummyClassSelector((MyViewable, NotViewable))
    codeflash_output = _is_viewable_class_selector(cs) # 2.05μs -> 1.35μs (52.4% faster)


def test_class_selector_class_is_none():
    # Should return False if class_ is None
    cs = DummyClassSelector(None)
    codeflash_output = _is_viewable_class_selector(cs) # 346ns -> 487ns (29.0% slower)

def test_class_selector_class_is_empty_tuple():
    # Should return True (vacuous truth) for empty tuple
    cs = DummyClassSelector(())
    codeflash_output = _is_viewable_class_selector(cs) # 425ns -> 545ns (22.0% slower)



def test_class_selector_class_is_non_type():
    # Should raise TypeError if class_ is not a type or tuple of types
    cs = DummyClassSelector(123)
    with pytest.raises(TypeError):
        _is_viewable_class_selector(cs) # 2.27μs -> 2.26μs (0.443% faster)


def test_class_selector_class_is_tuple_with_viewable_and_base_object():
    # Should return False if tuple contains object (not a subclass of Viewable)
    cs = DummyClassSelector((MyViewable, object))
    codeflash_output = _is_viewable_class_selector(cs) # 2.50μs -> 1.50μs (66.3% faster)

def test_class_selector_class_is_tuple_with_viewable_and_types_module_type():
    # Should return False if tuple contains a type unrelated to Viewable
    cs = DummyClassSelector((MyViewable, types.FunctionType))
    codeflash_output = _is_viewable_class_selector(cs) # 2.17μs -> 1.41μs (53.9% faster)

def test_class_selector_class_is_tuple_with_duplicate_classes():
    # Should return True if all are Viewable, even if duplicates
    cs = DummyClassSelector((MyViewable, MyViewable))
    codeflash_output = _is_viewable_class_selector(cs) # 2.01μs -> 1.37μs (46.5% faster)

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

def test_large_tuple_all_viewable():
    # Should return True for large tuple of Viewable subclasses
    classes = tuple(type(f"ViewableSub{i}", (Viewable,), {}) for i in range(500))
    cs = DummyClassSelector(classes)
    codeflash_output = _is_viewable_class_selector(cs) # 3.35μs -> 2.14μs (56.6% faster)

def test_large_tuple_one_non_viewable():
    # Should return False if any class is not a Viewable subclass
    classes = tuple(type(f"ViewableSub{i}", (Viewable,), {}) for i in range(499)) + (NotViewable,)
    cs = DummyClassSelector(classes)
    codeflash_output = _is_viewable_class_selector(cs) # 3.23μs -> 2.15μs (50.1% faster)

def test_large_tuple_all_non_viewable():
    # Should return False for large tuple of non-Viewable classes
    classes = tuple(type(f"NonViewable{i}", (), {}) for i in range(500))
    cs = DummyClassSelector(classes)
    codeflash_output = _is_viewable_class_selector(cs) # 3.37μs -> 2.28μs (47.9% faster)



def test_class_selector_class_is_bool():
    # Should raise TypeError if class_ is a bool
    cs = DummyClassSelector(True)
    with pytest.raises(TypeError):
        _is_viewable_class_selector(cs) # 2.44μs -> 2.63μs (7.55% slower)

def test_class_selector_class_is_string():
    # Should raise TypeError if class_ is a string
    cs = DummyClassSelector("Viewable")
    with pytest.raises(TypeError):
        _is_viewable_class_selector(cs) # 1.84μs -> 1.93μs (4.66% slower)

def test_class_selector_class_is_object_instance():
    # Should raise TypeError if class_ is an instance, not a type
    cs = DummyClassSelector(MyViewable())
    with pytest.raises(TypeError):
        _is_viewable_class_selector(cs) # 2.25μs -> 2.01μs (11.5% faster)

def test_class_selector_class_is_tuple_of_instances():
    # Should raise TypeError if tuple contains instances, not types
    cs = DummyClassSelector((MyViewable(),))
    with pytest.raises(TypeError):
        _is_viewable_class_selector(cs) # 2.92μs -> 2.18μs (34.0% 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 _is_viewable_class_selector
from param.parameters import Dict

def test__is_viewable_class_selector():
    _is_viewable_class_selector(Dict(default={}, instantiate='', is_instance=2, doc=0, label='', precedence='', constant=0, readonly='', pickle_default_value='', allow_None=0, per_instance=0, allow_refs=0, nested_refs=''))

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_kzgds56_/tmpesbjggc7/test_concolic_coverage.py::test__is_viewable_class_selector	2.49μs	2.31μs	7.84%✅

To edit these changes git checkout codeflash/optimize-_is_viewable_class_selector-mha0r616 and push.