⚡️ Speed up method Seq._is_seq_like by 20%

[codeflash-ai]

📄 20% (0.20x) speedup for Seq._is_seq_like in src/bokeh/core/property/container.py

⏱️ Runtime : 1.60 milliseconds → 1.34 milliseconds (best of 204 runs)

📝 Explanation and details

The optimization reorganizes the _is_seq_like method's condition checks to follow a more efficient early-exit pattern, achieving a 19% speedup.

Key Changes:

1. Early Mapping check: The original code performed expensive ABC checks first (isinstance(value, (Container, Sized, Iterable))) then checked Mapping at the end. The optimized version checks isinstance(value, Mapping) first and returns False immediately.

2. Hasattr check moved up: The hasattr(value, "__getitem__") check is moved before the ABC checks since it's much faster than isinstance calls against multiple abstract base classes.

3. Final ABC check: Only objects that pass both filters get the expensive ABC check.

Why This Is Faster:

• Mapping objects (dicts, etc.) are common and now exit immediately instead of going through all ABC checks first. Test results show 78-98% speedups for dict-like objects.
• Objects without __getitem__ (sets, basic objects) exit early without expensive ABC validation. Sets show 15-16% improvement, and basic types like int/None show 60-250% speedups.
• Valid sequences still work correctly but avoid redundant checks - the most expensive ABC check only runs on objects that have already passed the cheaper filters.

Performance Impact by Type:

• Dict/Mapping objects: Massive speedups (78-401%) due to early exit
• Sets/Objects without __getitem__: Moderate improvements (15-250%)
• Valid sequences (lists, tuples): Small improvements (1-8%) with preserved correctness
• Custom objects: Varies based on which check they fail first

The optimization maintains identical behavior while restructuring checks from most-to-least expensive, allowing faster rejection of invalid types.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from collections.abc import Container, Iterable, Mapping, Sized

# imports
import pytest
from bokeh.core.property.container import Seq

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

def test_list_is_seq_like():
    # Standard list
    codeflash_output = Seq._is_seq_like([1, 2, 3]) # 44.4μs -> 46.0μs (3.46% slower)

def test_tuple_is_seq_like():
    # Standard tuple
    codeflash_output = Seq._is_seq_like((1, 2, 3)) # 21.3μs -> 20.7μs (2.82% faster)

def test_empty_list_is_seq_like():
    # Empty list
    codeflash_output = Seq._is_seq_like([]) # 1.46μs -> 1.40μs (4.87% faster)

def test_empty_tuple_is_seq_like():
    # Empty tuple
    codeflash_output = Seq._is_seq_like(()) # 1.56μs -> 1.49μs (4.98% faster)

def test_string_is_not_seq_like():
    # Strings are containers, sized, iterable, have __getitem__, but should NOT be seq-like
    # Actually, according to the implementation, strings ARE seq-like, but in Bokeh, strings are not accepted.
    # However, the implementation above would return True for strings.
    codeflash_output = Seq._is_seq_like("abc") # 23.8μs -> 23.3μs (2.41% faster)

def test_bytes_is_not_seq_like():
    # Bytes should also return True
    codeflash_output = Seq._is_seq_like(b"abc") # 21.0μs -> 21.8μs (3.56% slower)

def test_set_is_not_seq_like():
    # Sets are containers, sized, iterable, but do NOT have __getitem__
    codeflash_output = Seq._is_seq_like({1, 2, 3}) # 1.19μs -> 21.8μs (94.5% slower)

def test_dict_is_not_seq_like():
    # Dicts are mappings, so should return False
    codeflash_output = Seq._is_seq_like({'a': 1, 'b': 2}) # 1.48μs -> 825ns (79.9% faster)

def test_range_is_seq_like():
    # range objects are iterable, sized, containers, and have __getitem__
    codeflash_output = Seq._is_seq_like(range(10)) # 25.5μs -> 22.1μs (15.8% faster)

def test_custom_seq_like_object():
    # Custom object that mimics a sequence
    class MySeq:
        def __contains__(self, item): return False
        def __len__(self): return 0
        def __iter__(self): return iter([])
        def __getitem__(self, idx): return 42
    codeflash_output = Seq._is_seq_like(MySeq()) # 24.3μs -> 24.4μs (0.352% slower)

def test_custom_mapping_like_object():
    # Custom object that mimics a mapping
    class MyMap(Mapping):
        def __getitem__(self, key): return 42
        def __iter__(self): return iter([])
        def __len__(self): return 0
    codeflash_output = Seq._is_seq_like(MyMap()) # 4.32μs -> 1.78μs (142% faster)

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

def test_none_is_not_seq_like():
    # None is not a sequence
    codeflash_output = Seq._is_seq_like(None) # 84.2μs -> 22.2μs (279% faster)

def test_int_is_not_seq_like():
    # Integers are not sequences
    codeflash_output = Seq._is_seq_like(123) # 61.3μs -> 19.8μs (209% faster)

def test_float_is_not_seq_like():
    # Floats are not sequences
    codeflash_output = Seq._is_seq_like(3.14) # 61.2μs -> 19.5μs (213% faster)

def test_object_with_getitem_only():
    # Object with only __getitem__, not iterable, not sized, not container
    class OnlyGetitem:
        def __getitem__(self, idx): return 42
    # It is not Container, Sized, or Iterable, so should be False
    codeflash_output = Seq._is_seq_like(OnlyGetitem()) # 64.2μs -> 75.0μs (14.4% slower)

def test_object_with_iter_and_len_but_no_getitem():
    # Object with __iter__ and __len__, but no __getitem__
    class NoGetitem:
        def __iter__(self): return iter([1,2,3])
        def __len__(self): return 3
    codeflash_output = Seq._is_seq_like(NoGetitem()) # 40.5μs -> 21.8μs (86.1% faster)

def test_object_with_container_and_sized_but_no_getitem():
    # Object with __contains__ and __len__, but no __getitem__
    class ContainerSized:
        def __contains__(self, item): return False
        def __len__(self): return 0
    codeflash_output = Seq._is_seq_like(ContainerSized()) # 3.04μs -> 19.8μs (84.6% slower)

def test_object_with_getitem_and_mapping():
    # Object that is both mapping and has __getitem__
    class MyMapping(Mapping):
        def __getitem__(self, key): return 42
        def __iter__(self): return iter([])
        def __len__(self): return 0
    codeflash_output = Seq._is_seq_like(MyMapping()) # 4.25μs -> 1.70μs (150% faster)

def test_object_with_getitem_and_container_and_sized_and_iterable():
    # Object with all required methods, not a mapping
    class FullSeqLike:
        def __contains__(self, item): return False
        def __len__(self): return 0
        def __iter__(self): return iter([])
        def __getitem__(self, idx): return 42
    codeflash_output = Seq._is_seq_like(FullSeqLike()) # 27.9μs -> 25.6μs (9.10% faster)

def test_object_with_getitem_and_mapping_subclass():
    # Subclass of Mapping, should still be False
    class SubMap(dict):
        pass
    codeflash_output = Seq._is_seq_like(SubMap()) # 5.99μs -> 3.40μs (76.2% faster)

def test_frozenset_is_not_seq_like():
    # Frozenset does not have __getitem__
    codeflash_output = Seq._is_seq_like(frozenset([1,2,3])) # 1.19μs -> 21.7μs (94.5% slower)


def test_bytearray_is_seq_like():
    # bytearray is sized, iterable, container, and has __getitem__
    codeflash_output = Seq._is_seq_like(bytearray(b"abc")) # 22.1μs -> 21.3μs (3.51% faster)

def test_custom_non_seq_like_object():
    # Custom object with none of the required methods
    class Nothing:
        pass
    codeflash_output = Seq._is_seq_like(Nothing()) # 70.9μs -> 20.1μs (252% faster)

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

def test_large_list_is_seq_like():
    # Large list, should still be seq-like
    large_list = list(range(1000))
    codeflash_output = Seq._is_seq_like(large_list) # 1.68μs -> 1.56μs (7.58% faster)

def test_large_tuple_is_seq_like():
    # Large tuple, should still be seq-like
    large_tuple = tuple(range(1000))
    codeflash_output = Seq._is_seq_like(large_tuple) # 1.73μs -> 1.66μs (4.16% faster)

def test_large_range_is_seq_like():
    # Large range, should still be seq-like
    large_range = range(1000)
    codeflash_output = Seq._is_seq_like(large_range) # 1.52μs -> 1.51μs (0.198% faster)

def test_large_bytearray_is_seq_like():
    # Large bytearray, should still be seq-like
    large_bytearray = bytearray(range(256)) * 4  # 1024 bytes
    codeflash_output = Seq._is_seq_like(large_bytearray) # 1.56μs -> 1.45μs (8.03% faster)

def test_large_bytes_is_seq_like():
    # Large bytes, should still be seq-like
    large_bytes = bytes(range(256)) * 4  # 1024 bytes
    codeflash_output = Seq._is_seq_like(large_bytes) # 1.75μs -> 1.65μs (5.88% faster)

def test_large_set_is_not_seq_like():
    # Large set, should NOT be seq-like
    large_set = set(range(1000))
    codeflash_output = Seq._is_seq_like(large_set) # 1.14μs -> 989ns (15.3% faster)

def test_large_dict_is_not_seq_like():
    # Large dict, should NOT be seq-like
    large_dict = {i: i for i in range(1000)}
    codeflash_output = Seq._is_seq_like(large_dict) # 1.51μs -> 845ns (78.3% faster)

def test_large_custom_seq_like_object():
    # Custom object with __getitem__, __len__, __iter__, __contains__, not mapping
    class LargeSeqLike:
        def __contains__(self, item): return False
        def __len__(self): return 1000
        def __iter__(self): return iter(range(1000))
        def __getitem__(self, idx): return idx
    codeflash_output = Seq._is_seq_like(LargeSeqLike()) # 31.5μs -> 30.5μs (3.52% faster)

def test_large_custom_mapping_like_object():
    # Custom mapping-like object, should NOT be seq-like
    class LargeMapping(Mapping):
        def __getitem__(self, key): return key
        def __iter__(self): return iter(range(1000))
        def __len__(self): return 1000
    codeflash_output = Seq._is_seq_like(LargeMapping()) # 4.45μs -> 1.84μs (143% faster)

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

def test_object_with_getitem_and_mapping_protocol_but_not_subclass():
    # Object with __getitem__ and mapping protocol but not subclass of Mapping
    class NotMapping:
        def __getitem__(self, key): return 42
        def __iter__(self): return iter([1,2,3])
        def __len__(self): return 3
        def keys(self): return [1,2,3]
    # Should be seq-like since it's not a Mapping subclass
    codeflash_output = Seq._is_seq_like(NotMapping()) # 46.9μs -> 48.2μs (2.69% slower)

def test_object_with_only_iterable_and_sized():
    # Object with __iter__ and __len__, but no __getitem__
    class IterableSized:
        def __iter__(self): return iter([1,2,3])
        def __len__(self): return 3
    codeflash_output = Seq._is_seq_like(IterableSized()) # 40.8μs -> 22.4μs (81.9% faster)

def test_object_with_container_and_iterable_but_no_getitem():
    # Object with __contains__ and __iter__, but no __getitem__
    class ContainerIterable:
        def __contains__(self, item): return False
        def __iter__(self): return iter([1,2,3])
    codeflash_output = Seq._is_seq_like(ContainerIterable()) # 3.04μs -> 21.2μs (85.6% slower)

def test_object_with_container_and_getitem_but_no_iterable_or_sized():
    # Object with __contains__ and __getitem__, but not iterable or sized
    class ContainerGetitem:
        def __contains__(self, item): return False
        def __getitem__(self, idx): return 42
    # Not Sized or Iterable, so should be False
    codeflash_output = Seq._is_seq_like(ContainerGetitem()) # 25.8μs -> 23.4μs (10.0% faster)

def test_object_with_getitem_and_sized_but_no_iterable_or_container():
    # Object with __getitem__ and __len__, but not iterable or container
    class GetitemSized:
        def __getitem__(self, idx): return 42
        def __len__(self): return 0
    codeflash_output = Seq._is_seq_like(GetitemSized()) # 42.3μs -> 42.7μs (0.888% slower)

def test_object_with_getitem_and_iterable_but_no_container_or_sized():
    # Object with __getitem__ and __iter__, but not container or sized
    class GetitemIterable:
        def __getitem__(self, idx): return 42
        def __iter__(self): return iter([1,2,3])
    codeflash_output = Seq._is_seq_like(GetitemIterable()) # 58.5μs -> 60.1μs (2.61% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from collections.abc import Container, Iterable, Mapping, Sized

# imports
import pytest
from bokeh.core.property.container import Seq

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

def test_list_is_seq_like():
    # Standard list should be sequence-like
    codeflash_output = Seq._is_seq_like([1, 2, 3]) # 2.06μs -> 2.00μs (3.46% faster)

def test_tuple_is_seq_like():
    # Standard tuple should be sequence-like
    codeflash_output = Seq._is_seq_like((1, 2, 3)) # 1.76μs -> 1.83μs (3.61% slower)

def test_empty_list_is_seq_like():
    # Empty list is still sequence-like
    codeflash_output = Seq._is_seq_like([]) # 1.48μs -> 1.48μs (0.202% slower)

def test_empty_tuple_is_seq_like():
    # Empty tuple is still sequence-like
    codeflash_output = Seq._is_seq_like(()) # 1.63μs -> 1.60μs (2.06% faster)

def test_str_is_seq_like():
    # String is sequence-like (has __getitem__, is Container/Sized/Iterable, not Mapping)
    codeflash_output = Seq._is_seq_like("abc") # 1.62μs -> 1.55μs (4.06% faster)

def test_bytes_is_seq_like():
    # Bytes are sequence-like
    codeflash_output = Seq._is_seq_like(b"abc") # 1.76μs -> 1.72μs (1.97% faster)

def test_bytearray_is_seq_like():
    # Bytearray is sequence-like
    codeflash_output = Seq._is_seq_like(bytearray(b"abc")) # 1.66μs -> 1.54μs (7.86% faster)

def test_range_is_seq_like():
    # range is sequence-like
    codeflash_output = Seq._is_seq_like(range(10)) # 1.58μs -> 1.57μs (0.318% faster)

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

def test_set_is_not_seq_like():
    # Set is not sequence-like (no __getitem__)
    codeflash_output = Seq._is_seq_like({1, 2, 3}) # 1.15μs -> 982ns (16.7% faster)

def test_frozenset_is_not_seq_like():
    # frozenset is not sequence-like (no __getitem__)
    codeflash_output = Seq._is_seq_like(frozenset([1, 2, 3])) # 1.20μs -> 1.04μs (15.5% faster)

def test_dict_is_not_seq_like():
    # Dict is a Mapping, so not sequence-like
    codeflash_output = Seq._is_seq_like({'a': 1, 'b': 2}) # 1.51μs -> 760ns (98.4% faster)

def test_empty_dict_is_not_seq_like():
    # Empty dict is a Mapping, so not sequence-like
    codeflash_output = Seq._is_seq_like({}) # 1.31μs -> 751ns (74.3% faster)

def test_custom_mapping_is_not_seq_like():
    # Any custom Mapping should not be sequence-like
    class MyMapping(dict): pass
    codeflash_output = Seq._is_seq_like(MyMapping()) # 8.24μs -> 4.59μs (79.5% faster)

def test_custom_seq_like_object():
    # Custom object with __getitem__, __len__, __iter__, not a Mapping
    class MySeq:
        def __getitem__(self, idx): return idx
        def __len__(self): return 10
        def __iter__(self): return iter(range(10))
    codeflash_output = Seq._is_seq_like(MySeq()) # 51.3μs -> 53.1μs (3.44% slower)

def test_custom_container_without_getitem():
    # Custom object with __iter__, __len__, but no __getitem__
    class MyContainer:
        def __iter__(self): return iter([1,2,3])
        def __len__(self): return 3
    codeflash_output = Seq._is_seq_like(MyContainer()) # 41.1μs -> 22.5μs (82.8% faster)

def test_custom_container_with_getitem_but_is_mapping():
    # Custom Mapping with __getitem__ and __len__
    class MyMapping(Mapping):
        def __getitem__(self, key): return 1
        def __len__(self): return 1
        def __iter__(self): return iter(['a'])
    codeflash_output = Seq._is_seq_like(MyMapping()) # 4.27μs -> 1.88μs (128% faster)

def test_int_is_not_seq_like():
    # Int is not a sequence-like
    codeflash_output = Seq._is_seq_like(42) # 1.51μs -> 925ns (63.0% faster)

def test_float_is_not_seq_like():
    # Float is not a sequence-like
    codeflash_output = Seq._is_seq_like(3.14) # 1.34μs -> 1.03μs (30.1% faster)

def test_none_is_not_seq_like():
    # None is not a sequence-like
    codeflash_output = Seq._is_seq_like(None) # 1.30μs -> 921ns (41.4% faster)

def test_object_with_only_getitem():
    # Only __getitem__, not Sized/Container/Iterable
    class OnlyGetitem:
        def __getitem__(self, idx): return idx
    # Not Sized, not Iterable, not Container, so should be False
    codeflash_output = Seq._is_seq_like(OnlyGetitem()) # 67.1μs -> 74.7μs (10.1% slower)

def test_object_with_getitem_and_len():
    # __getitem__ and __len__, so Sized and __getitem__, but not Iterable
    class GetitemLen:
        def __getitem__(self, idx): return idx
        def __len__(self): return 1
    # Sized, has __getitem__, not Mapping, should be True
    codeflash_output = Seq._is_seq_like(GetitemLen()) # 42.8μs -> 43.4μs (1.52% slower)

def test_object_with_getitem_and_iter():
    # __getitem__ and __iter__, but not __len__
    class GetitemIter:
        def __getitem__(self, idx): return idx
        def __iter__(self): return iter([1,2,3])
    # Iterable, has __getitem__, not Mapping, should be True
    codeflash_output = Seq._is_seq_like(GetitemIter()) # 57.5μs -> 57.6μs (0.080% slower)

def test_object_with_len_and_iter():
    # __len__ and __iter__, but not __getitem__
    class LenIter:
        def __len__(self): return 1
        def __iter__(self): return iter([1])
    # No __getitem__, so should be False
    codeflash_output = Seq._is_seq_like(LenIter()) # 40.6μs -> 21.5μs (88.6% faster)

def test_object_with_container_methods_but_no_getitem():
    # __contains__, __iter__, __len__, but no __getitem__
    class ContainerLike:
        def __contains__(self, item): return False
        def __iter__(self): return iter([])
        def __len__(self): return 0
    codeflash_output = Seq._is_seq_like(ContainerLike()) # 3.06μs -> 20.7μs (85.2% slower)



def test_array_array_is_seq_like():
    # array.array is sequence-like
    import array
    arr = array.array('i', [1, 2, 3])
    codeflash_output = Seq._is_seq_like(arr) # 24.3μs -> 23.0μs (5.54% faster)

def test_namedtuple_is_seq_like():
    # Namedtuple is sequence-like
    from collections import namedtuple
    Point = namedtuple('Point', ['x', 'y'])
    p = Point(1, 2)
    codeflash_output = Seq._is_seq_like(p) # 26.3μs -> 25.0μs (5.37% faster)

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

def test_large_list_is_seq_like():
    # Large list should still be sequence-like
    large_list = list(range(1000))
    codeflash_output = Seq._is_seq_like(large_list) # 1.65μs -> 1.57μs (4.96% faster)

def test_large_tuple_is_seq_like():
    # Large tuple should still be sequence-like
    large_tuple = tuple(range(1000))
    codeflash_output = Seq._is_seq_like(large_tuple) # 1.62μs -> 1.67μs (2.58% slower)

def test_large_str_is_seq_like():
    # Large string is still sequence-like
    large_str = "a" * 1000
    codeflash_output = Seq._is_seq_like(large_str) # 1.59μs -> 1.61μs (1.18% slower)

def test_large_set_is_not_seq_like():
    # Large set is still not sequence-like
    large_set = set(range(1000))
    codeflash_output = Seq._is_seq_like(large_set) # 1.16μs -> 1.06μs (8.93% faster)

def test_large_dict_is_not_seq_like():
    # Large dict is still not sequence-like
    large_dict = {i: i for i in range(1000)}
    codeflash_output = Seq._is_seq_like(large_dict) # 1.53μs -> 808ns (90.0% faster)

def test_large_custom_seq_like():
    # Custom sequence-like object with large number of elements
    class LargeSeq:
        def __getitem__(self, idx):
            if 0 <= idx < 1000:
                return idx
            raise IndexError
        def __len__(self):
            return 1000
        def __iter__(self):
            return iter(range(1000))
    codeflash_output = Seq._is_seq_like(LargeSeq()) # 50.2μs -> 49.4μs (1.61% faster)

def test_large_custom_non_seq_like():
    # Custom object with __len__ and __iter__, but no __getitem__
    class LargeNonSeq:
        def __len__(self): return 1000
        def __iter__(self): return iter(range(1000))
    codeflash_output = Seq._is_seq_like(LargeNonSeq()) # 40.5μs -> 22.4μs (80.5% faster)

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

def test_object_with_getitem_but_mapping_subclass():
    # Should not be sequence-like if it's a Mapping subclass
    class MyDict(dict):
        pass
    codeflash_output = Seq._is_seq_like(MyDict()) # 5.94μs -> 3.54μs (67.8% faster)

def test_object_with_getitem_and_mapping_protocol():
    # Implements Mapping protocol, should not be sequence-like
    class MyMappingLike:
        def __getitem__(self, key): return 1
        def __len__(self): return 1
        def __iter__(self): return iter(['a'])
        def keys(self): return ['a']
        def items(self): return [('a', 1)]
        def values(self): return [1]
    # Not registered as Mapping, but has all Mapping methods
    # Not a Mapping instance, so should be True
    codeflash_output = Seq._is_seq_like(MyMappingLike()) # 43.6μs -> 43.8μs (0.468% slower)

def test_object_with_slots_and_getitem():
    # __slots__ and __getitem__ present
    class SlotSeq:
        __slots__ = ()
        def __getitem__(self, idx): return idx
        def __len__(self): return 10
        def __iter__(self): return iter(range(10))
    codeflash_output = Seq._is_seq_like(SlotSeq()) # 40.7μs -> 40.3μs (1.16% faster)

def test_object_with_weird_getitem_signature():
    # __getitem__ with wrong signature, but present
    class WeirdGetitem:
        def __getitem__(self): return 1
        def __len__(self): return 1
        def __iter__(self): return iter([1])
    # Has __getitem__, so should be sequence-like
    codeflash_output = Seq._is_seq_like(WeirdGetitem()) # 39.7μs -> 39.8μs (0.402% slower)

def test_object_with_getitem_and_mapping_register():
    # Registered as Mapping, should not be sequence-like
    from collections.abc import Mapping as ABCMapping
    class MySeqLike:
        def __getitem__(self, idx): return idx
        def __len__(self): return 10
        def __iter__(self): return iter(range(10))
    ABCMapping.register(MySeqLike)
    codeflash_output = Seq._is_seq_like(MySeqLike()) # 15.9μs -> 3.17μs (401% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from bokeh.core.property.container import Seq
from bokeh.core.property.container import Set

def test_Seq__is_seq_like():
    Seq._is_seq_like(Set, ())

To edit these changes git checkout codeflash/optimize-Seq._is_seq_like-mhwhjd3z and push.