⚡️ Speed up function _sphinx_type_seq by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for _sphinx_type_seq in src/bokeh/core/property/container.py

⏱️ Runtime : 775 microseconds → 728 microseconds (best of 250 runs)

📝 Explanation and details

The optimization introduces memoization caching to the property_link function, which eliminates redundant string formatting operations for objects of the same class.

Key Optimization:

• Added _property_link_cache dictionary to store pre-computed string results per class type
• The function now checks the cache first before performing expensive string formatting
• Only computes the Sphinx documentation link string once per unique class type

Why This Works:
The original code performed string formatting (f":class:~bokeh.core.properties.{obj.class.name}\\ ") on every call, even for objects of the same class. String formatting with f-strings and attribute access (obj.__class__.__name__) has measurable overhead when called frequently. The cache eliminates this redundant work by storing the result after the first computation.

Performance Impact:

• Line profiler shows the optimization reduces property_link calls from 328ns to 214ns per hit on average
• Cache hits (19,299 out of 19,507 calls) return in ~190ns vs ~387ns for cache misses
• Only 208 unique classes required string formatting, meaning 98.9% of calls benefited from caching
• Overall 6% speedup demonstrates the cumulative effect of avoiding repeated string operations

Test Case Performance:
The optimization performs best with repeated calls using the same types - test cases show 10-30% improvements for scenarios with common built-in types (int, str, float) and custom classes. Large-scale tests with 1000+ iterations show consistent 8-16% improvements, validating the caching strategy's effectiveness for high-volume documentation generation workloads.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from bokeh.core.property.container import _sphinx_type_seq


# Function to test (minimal working version)
class Seq:
    def __init__(self, item_type):
        self.item_type = item_type

class DummyType:
    pass
from bokeh.core.property.container import _sphinx_type_seq

# --------------------------
# Unit tests for _sphinx_type_seq
# --------------------------

# 1. Basic Test Cases

def test_basic_with_builtin_type():
    # Test with a basic builtin type (int)
    seq = Seq(int)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.94μs -> 1.62μs (20.0% faster)

def test_basic_with_str_type():
    # Test with str type
    seq = Seq(str)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.68μs -> 1.35μs (24.4% faster)

def test_basic_with_custom_type():
    # Test with a custom class
    class Custom:
        pass
    seq = Seq(Custom)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.69μs -> 1.36μs (24.6% faster)

def test_basic_with_dummytype_instance():
    # Test with an instance of DummyType as item_type (should use its class name)
    dummy = DummyType()
    seq = Seq(dummy)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.54μs -> 1.38μs (12.0% faster)

# 2. Edge Test Cases

def test_edge_with_none_type():
    # Test with NoneType as item_type
    seq = Seq(type(None))
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.63μs -> 1.30μs (25.2% faster)

def test_edge_with_seq_of_seq():
    # Test with Seq of Seq (nested sequence)
    inner_seq = Seq(float)
    seq = Seq(type(inner_seq))
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.57μs -> 1.23μs (27.9% faster)

def test_edge_with_object_type():
    # Test with object as item_type
    seq = Seq(object)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.55μs -> 1.19μs (30.6% faster)

def test_edge_with_unusual_type_name():
    # Test with a type having unusual name
    class _WeirdType123:
        pass
    seq = Seq(_WeirdType123)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.58μs -> 1.30μs (21.9% faster)

def test_edge_with_non_type_item():
    # Test with a non-type, non-instance item_type (e.g., a string literal)
    seq = Seq("notatype")
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.70μs -> 1.30μs (30.0% faster)

def test_edge_with_int_instance():
    # Test with an integer instance as item_type
    seq = Seq(42)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.64μs -> 1.29μs (26.7% faster)

def test_edge_with_callable_item_type():
    # Test with a function as item_type
    def func(): pass
    seq = Seq(func)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.63μs -> 1.25μs (30.5% faster)

def test_edge_with_class_instance_item_type():
    # Test with a class instance as item_type
    class Foo: pass
    foo = Foo()
    seq = Seq(foo)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.63μs -> 1.94μs (16.1% slower)

# 3. Large Scale Test Cases

def test_large_scale_with_many_types():
    # Test with many different types in a loop
    # This checks for performance and correctness with many types
    for t in [int, str, float, bool, dict, list, tuple, set, frozenset, complex, bytes]:
        seq = Seq(t)
        codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 6.40μs -> 5.52μs (16.1% faster)
        expected = f":class:`~bokeh.core.properties.Seq`\\ (:class:`~bokeh.core.properties.{t.__name__}`\\ )"

def test_large_scale_with_many_custom_types():
    # Test with 100 custom types (scalability)
    class CustomBase: pass
    for i in range(100):
        # Dynamically create a new type
        CustomType = type(f"CustomType{i}", (CustomBase,), {})
        seq = Seq(CustomType)
        codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 46.8μs -> 42.4μs (10.5% faster)
        expected = f":class:`~bokeh.core.properties.Seq`\\ (:class:`~bokeh.core.properties.CustomType{i}`\\ )"

def test_large_scale_with_many_seq_instances():
    # Test with 1000 Seq instances (scalability)
    types = [int, str, float, bool, dict, list, tuple, set, frozenset, complex, bytes]
    for i in range(1000):
        t = types[i % len(types)]
        seq = Seq(t)
        codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 417μs -> 385μs (8.27% faster)
        expected = f":class:`~bokeh.core.properties.Seq`\\ (:class:`~bokeh.core.properties.{t.__name__}`\\ )"

def test_large_scale_with_long_class_name():
    # Test with a custom type with a very long class name
    LongNameType = type("ThisIsAnExcessivelyLongClassNameForTestingEdgeCasesInSphinxTypeSeq", (), {})
    seq = Seq(LongNameType)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.95μs -> 1.63μs (19.6% faster)
    expected = ":class:`~bokeh.core.properties.Seq`\\ (:class:`~bokeh.core.properties.ThisIsAnExcessivelyLongClassNameForTestingEdgeCasesInSphinxTypeSeq`\\ )"
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from typing import Any, Callable

# imports
import pytest  # used for our unit tests
from bokeh.core.property.container import _sphinx_type_seq

# --- Minimal stubs and setup to allow testing the function as described ---


_type_links: dict[type, Callable[[Any], str]] = {}

def register_type_link(cls):
    # Decorator to register type link functions
    def decorator(func):
        _type_links[cls] = func
        return func
    return decorator

# --- Simulate bokeh.core.property.container.py ---

# Minimal stub for Seq, with .item_type attribute
class Seq:
    def __init__(self, item_type):
        self.item_type = item_type

# For item_type, we need something that can be passed to type_link.
# We'll simulate a few property types.
class Int:
    pass

class String:
    pass

class CustomProperty:
    pass
from bokeh.core.property.container import _sphinx_type_seq

# --- Unit tests for _sphinx_type_seq ---

# 1. Basic Test Cases

def test_seq_with_int_type():
    # Test with Int property type
    seq = Seq(Int())
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.44μs -> 1.28μs (12.5% faster)

def test_seq_with_string_type():
    # Test with String property type
    seq = Seq(String())
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.58μs -> 1.36μs (15.9% faster)

def test_seq_with_custom_type():
    # Test with a custom property type
    seq = Seq(CustomProperty())
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.38μs -> 1.24μs (11.2% faster)

# 2. Edge Test Cases

def test_seq_with_unregistered_type():
    # Test with an item_type that has no registered type_link
    class UnregisteredType:
        pass
    seq = Seq(UnregisteredType())
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.61μs -> 1.94μs (17.2% slower)

def test_seq_with_none_type():
    # Test with None as item_type (should not crash)
    seq = Seq(None)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.62μs -> 1.31μs (23.6% faster)

def test_seq_with_builtin_type():
    # Test with a built-in type as item_type (e.g. int)
    seq = Seq(int)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.64μs -> 1.27μs (28.7% faster)

def test_seq_with_object_type():
    # Test with a generic object as item_type
    seq = Seq(object())
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.57μs -> 1.31μs (19.5% faster)

def test_seq_with_missing_item_type_attribute():
    # Test with a Seq missing item_type attribute
    class BadSeq:
        pass
    bad_seq = BadSeq()
    with pytest.raises(AttributeError):
        _sphinx_type_seq(bad_seq) # 1.89μs -> 2.19μs (13.4% slower)

def test_seq_with_item_type_as_class():
    # Test with item_type as a class, not instance
    seq = Seq(Int)
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.74μs -> 1.46μs (18.9% faster)

# 3. Large Scale Test Cases

def test_many_seq_types():
    # Test with many different item_types in a loop
    class DummyType:
        pass
    for i in range(100):  # 100 different types
        # Dynamically create a new type each time
        NewType = type(f"DummyType{i}", (), {})
        seq = Seq(NewType())
        codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 48.4μs -> 53.3μs (9.23% slower)

def test_large_seq_with_same_type():
    # Test with a large number of Seq objects with the same item_type
    seqs = [Seq(Int()) for _ in range(500)]
    for seq in seqs:
        codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 204μs -> 194μs (5.53% faster)

def test_seq_with_deeply_nested_types():
    # Test with item_type that itself is a Seq of another type
    inner_seq = Seq(Int())
    outer_seq = Seq(inner_seq)
    codeflash_output = _sphinx_type_seq(outer_seq); result = codeflash_output # 1.62μs -> 1.29μs (24.9% faster)
    # Should link to Seq and then to Seq(Int)
    expected = ":class:`~bokeh.core.properties.Seq`\\ (:class:`~bokeh.core.properties.Seq`\\ (:class:`~bokeh.core.properties.Int`\\ ))"

def test_seq_with_long_chain_of_nested_types():
    # Test with a chain of nested Seq types (depth 5)
    seq = Seq(Seq(Seq(Seq(Seq(Int())))))
    codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 1.35μs -> 1.16μs (16.5% faster)
    # Build expected string
    expected = ":class:`~bokeh.core.properties.Seq`\\ (" \
               ":class:`~bokeh.core.properties.Seq`\\ (" \
               ":class:`~bokeh.core.properties.Seq`\\ (" \
               ":class:`~bokeh.core.properties.Seq`\\ (" \
               ":class:`~bokeh.core.properties.Seq`\\ (:class:`~bokeh.core.properties.Int`\\ )))))"

def test_seq_with_varied_types_large():
    # Test with a large number of Seq objects with varied types
    types = [Int(), String(), CustomProperty()] + [type(f"T{i}", (), {})() for i in range(20)]
    for t in types:
        seq = Seq(t)
        codeflash_output = _sphinx_type_seq(seq); result = codeflash_output # 12.0μs -> 12.9μs (7.41% slower)
        expected_type_name = t.__class__.__name__
# 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-_sphinx_type_seq-mhwiavjd and push.