⚡️ Speed up function _sphinx_type_link by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for _sphinx_type_link in src/bokeh/core/property/required.py

⏱️ Runtime : 663 microseconds → 608 microseconds (best of 250 runs)

📝 Explanation and details

The optimization introduces an LRU cache to avoid redundant string formatting operations in the property_link function. The key changes are:

What was optimized:

• Extracted string formatting logic into a separate cached function _property_link_class_name(cls: type) decorated with @lru_cache(maxsize=128)
• Changed obj.__class__ to type(obj) for more direct type retrieval
• Cached the expensive string interpolation f":class:~bokeh.core.properties.{cls.name}\\ " based on class type

Why this improves performance:
The original code performed string formatting on every call to property_link, even when the same class types were processed repeatedly. With the LRU cache, identical class types only compute the formatted string once and reuse the cached result. Since Sphinx documentation generation typically processes many objects of the same types (like Required, int, str, etc.), this caching provides significant benefit.

Performance impact:

• 9% overall speedup (663μs → 608μs runtime)
• Per-hit improvement in property_link: 340.4ns → 325.1ns per call (4.5% faster per call)
• The line profiler shows similar hit counts but reduced total time, confirming the caching benefit

Test case effectiveness:
The optimization excels with repeated class types - test cases with builtin types (int, str, list, dict) and identical custom classes show 10-40% speedups. The cache is less beneficial for unique class types (some tests show slight slowdowns due to cache overhead), but the overall workload benefits since documentation generation typically involves many instances of common property types.

The maxsize=128 limit prevents unbounded memory growth while accommodating the typical variety of property classes in Bokeh's documentation generation.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any

# imports
import pytest
from bokeh.core.property.required import _sphinx_type_link


# Minimal stubs to enable testing without Bokeh's full codebase
class SingleParameterizedProperty:
    def __init__(self, type_param: Any):
        self.type_param = type_param

class DummyTypeParam:
    pass

class DummyOtherTypeParam:
    pass

# Simulate the _type_links registry mechanism
_type_links = {}

def register_type_link(cls):
    def decorator(fn):
        _type_links[cls] = fn
        return fn
    return decorator

# Simulate Required property class
class Required(SingleParameterizedProperty):
    pass
from bokeh.core.property.required import _sphinx_type_link


# Additional dummy classes for type_param to test various scenarios
class CustomTypeParam:
    pass

class AnotherTypeParam:
    pass

# -------------------------------
# Unit Tests for _sphinx_type_link
# -------------------------------

# --- Basic Test Cases ---

def test_basic_with_builtin_type_param():
    """Test with a built-in type_param (int)"""
    req = Required(int)
    # type_link(int) should fallback to property_link(int)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.int`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.63μs -> 1.32μs (23.7% faster)

def test_basic_with_custom_type_param():
    """Test with a custom type_param with a registered type_link"""
    type_param = CustomTypeParam()
    req = Required(type_param)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~custom.module.CustomTypeParam`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.36μs -> 1.22μs (11.9% faster)

def test_basic_with_unregistered_type_param():
    """Test with an unregistered custom type_param"""
    type_param = DummyTypeParam()
    req = Required(type_param)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.DummyTypeParam`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.47μs -> 1.29μs (13.7% faster)

def test_basic_with_another_registered_type_param():
    """Test with another type_param with a registered type_link"""
    type_param = AnotherTypeParam()
    req = Required(type_param)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~another.module.AnotherTypeParam`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.42μs -> 1.23μs (15.3% faster)

# --- Edge Test Cases ---

def test_edge_with_none_type_param():
    """Test with None as type_param"""
    req = Required(None)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.NoneType`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.67μs -> 1.22μs (37.2% faster)

def test_edge_with_type_param_as_class():
    """Test with type_param as a class object, not instance"""
    req = Required(DummyOtherTypeParam)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.type`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.50μs -> 1.20μs (25.1% faster)

def test_edge_with_type_param_as_str():
    """Test with type_param as a string"""
    req = Required("string_type")
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.str`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.61μs -> 1.28μs (25.5% faster)

def test_edge_with_type_param_as_int():
    """Test with type_param as an integer"""
    req = Required(42)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.int`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.65μs -> 1.21μs (36.6% faster)

def test_edge_with_type_param_as_list():
    """Test with type_param as a list"""
    req = Required([1, 2, 3])
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.list`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.54μs -> 1.32μs (16.4% faster)

def test_edge_with_type_param_as_dict():
    """Test with type_param as a dict"""
    req = Required({'a': 1})
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.dict`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.60μs -> 1.19μs (34.1% faster)

def test_edge_with_type_param_as_tuple():
    """Test with type_param as a tuple"""
    req = Required((1, 2))
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.tuple`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.74μs -> 1.20μs (44.6% faster)

def test_edge_with_type_param_as_float():
    """Test with type_param as a float"""
    req = Required(3.14)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.float`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.60μs -> 1.29μs (24.2% faster)

def test_edge_with_type_param_as_bool():
    """Test with type_param as a boolean"""
    req = Required(True)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.bool`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.62μs -> 1.24μs (31.3% faster)

def test_edge_with_type_param_as_bytes():
    """Test with type_param as bytes"""
    req = Required(b"bytes")
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.bytes`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.59μs -> 1.22μs (29.6% faster)

def test_edge_with_type_param_as_object():
    """Test with type_param as a generic object"""
    req = Required(object())
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.object`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.61μs -> 1.23μs (31.3% faster)

def test_edge_with_type_param_as_set():
    """Test with type_param as a set"""
    req = Required({1, 2, 3})
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.set`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.66μs -> 1.18μs (40.1% faster)

def test_edge_with_type_param_as_frozenset():
    """Test with type_param as a frozenset"""
    req = Required(frozenset([1, 2, 3]))
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.frozenset`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.68μs -> 1.25μs (34.7% faster)

def test_edge_with_type_param_as_complex():
    """Test with type_param as a complex number"""
    req = Required(1+2j)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.complex`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.70μs -> 1.20μs (41.9% faster)

def test_edge_with_type_param_with_same_class_name():
    """Test with two different classes with the same name from different modules"""
    # Simulate two different classes named 'CustomTypeParam'
    class CustomTypeParamA:
        pass
    class CustomTypeParamB:
        pass
    a = CustomTypeParamA()
    b = CustomTypeParamB()
    req_a = Required(a)
    req_b = Required(b)
    expected_a = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.CustomTypeParamA`\\ )"
    expected_b = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.CustomTypeParamB`\\ )"
    codeflash_output = _sphinx_type_link(req_a) # 1.57μs -> 2.29μs (31.5% slower)
    codeflash_output = _sphinx_type_link(req_b) # 779ns -> 915ns (14.9% slower)

def test_edge_with_type_param_as_function():
    """Test with type_param as a function"""
    def dummy_func():
        pass
    req = Required(dummy_func)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.function`\\ )"
    # In Python, functions are of type 'function'
    codeflash_output = _sphinx_type_link(req) # 1.51μs -> 1.17μs (29.3% faster)

def test_edge_with_type_param_as_lambda():
    """Test with type_param as a lambda function"""
    req = Required(lambda x: x)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.function`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.50μs -> 1.16μs (29.3% faster)

def test_edge_with_type_param_as_module():
    """Test with type_param as a module"""
    import math
    req = Required(math)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.module`\\ )"
    codeflash_output = _sphinx_type_link(req) # 1.57μs -> 1.23μs (27.7% faster)

# --- Large Scale Test Cases ---

def test_large_scale_with_many_unique_type_params():
    """Test with many Required objects having unique type_param classes"""
    class BaseTypeParam:
        pass
    results = []
    for i in range(100):
        # Dynamically create new classes
        cls = type(f"TypeParam{i}", (BaseTypeParam,), {})
        instance = cls()
        req = Required(instance)
        expected = f":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.TypeParam{i}`\\ )"
        results.append(_sphinx_type_link(req) == expected) # 49.5μs -> 61.1μs (19.1% slower)

def test_large_scale_with_many_builtin_type_params():
    """Test with many Required objects having builtin type_param values"""
    results = []
    for i in range(100):
        req = Required(i)
        expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.int`\\ )"
        results.append(_sphinx_type_link(req) == expected) # 46.4μs -> 41.5μs (12.0% faster)

def test_large_scale_with_many_strings():
    """Test with many Required objects having string type_param values"""
    results = []
    for i in range(100):
        req = Required(str(i))
        expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.str`\\ )"
        results.append(_sphinx_type_link(req) == expected) # 46.0μs -> 41.3μs (11.3% faster)

def test_large_scale_with_mixed_type_params():
    """Test with many Required objects having a mix of type_param types"""
    results = []
    for i in range(25):
        req_int = Required(i)
        req_str = Required(str(i))
        req_list = Required([i])
        req_dict = Required({i: i})
        req_tuple = Required((i,))
        expected_int = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.int`\\ )"
        expected_str = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.str`\\ )"
        expected_list = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.list`\\ )"
        expected_dict = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.dict`\\ )"
        expected_tuple = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.tuple`\\ )"
        results.extend([
            _sphinx_type_link(req_int) == expected_int,
            _sphinx_type_link(req_str) == expected_str,
            _sphinx_type_link(req_list) == expected_list,
            _sphinx_type_link(req_dict) == expected_dict,
            _sphinx_type_link(req_tuple) == expected_tuple,
        ]) # 12.6μs -> 11.2μs (13.3% 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 bokeh.core.property.required import _sphinx_type_link


# Minimal stubs to allow the test to run without Bokeh installed
class SingleParameterizedProperty:
    def __init__(self, type_param):
        self.type_param = type_param

class Required(SingleParameterizedProperty):
    pass

# Simulate the _type_links registry and decorator
_type_links = {}

def register_type_link(cls):
    # Decorator to register a type link function for a class
    def decorator(func):
        _type_links[cls] = func
        return func
    return decorator
from bokeh.core.property.required import _sphinx_type_link

# ---- UNIT TESTS ----

# 1. Basic Test Cases

def test_basic_required_int():
    """Test Required property with int type_param."""
    r = Required(int)
    # property_link(r) should use Required, type_link(int) should use property_link(int)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.int`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.78μs -> 1.46μs (21.6% faster)

def test_basic_required_str():
    """Test Required property with str type_param."""
    r = Required(str)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.str`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.53μs -> 1.26μs (21.6% faster)

def test_basic_required_custom_class():
    """Test Required property with a custom class type_param."""
    class MyType: pass
    r = Required(MyType)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.MyType`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.57μs -> 1.26μs (24.3% faster)

# 2. Edge Test Cases

def test_required_with_none_type_param():
    """Test Required property with None as type_param."""
    r = Required(None)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.NoneType`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.69μs -> 1.24μs (36.4% faster)

def test_required_with_builtin_type_param():
    """Test Required property with a builtin type as type_param."""
    r = Required(float)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.float`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.47μs -> 1.13μs (30.4% faster)

def test_required_with_type_param_that_is_required():
    """Test Required property with another Required as type_param."""
    inner = Required(str)
    outer = Required(inner)
    # property_link(inner) should use Required, so type_link(inner) should use _sphinx_type_link
    expected_inner = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.str`\\ )"
    expected = f":class:`~bokeh.core.properties.Required`\\ ({expected_inner})"
    codeflash_output = _sphinx_type_link(outer) # 1.41μs -> 1.23μs (14.4% faster)

def test_required_with_type_param_that_is_single_parameterized_property():
    """Test Required property with SingleParameterizedProperty as type_param."""
    class Dummy(SingleParameterizedProperty): pass
    dummy = Dummy(int)
    r = Required(dummy)
    expected_dummy = ":class:`~bokeh.core.properties.Dummy`\\ (:class:`~bokeh.core.properties.int`\\ )"
    expected = f":class:`~bokeh.core.properties.Required`\\ ({expected_dummy})"
    codeflash_output = _sphinx_type_link(r) # 1.53μs -> 2.30μs (33.5% slower)

def test_required_with_type_param_that_is_object_instance():
    """Test Required property with a generic object instance as type_param."""
    obj = object()
    r = Required(obj)
    # object's class name is 'object'
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.object`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.61μs -> 1.27μs (26.3% faster)

def test_required_with_type_param_that_is_type_object():
    """Test Required property with a type object as type_param."""
    r = Required(type)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.type`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.49μs -> 1.17μs (27.3% faster)

def test_required_with_type_param_that_is_function():
    """Test Required property with a function as type_param."""
    def foo(): pass
    r = Required(foo)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.function`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.58μs -> 1.25μs (26.9% faster)

def test_required_with_type_param_that_is_lambda():
    """Test Required property with a lambda as type_param."""
    r = Required(lambda x: x)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.function`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.50μs -> 1.18μs (27.3% faster)

def test_required_with_type_param_that_is_class():
    """Test Required property with a class as type_param."""
    class Foo: pass
    r = Required(Foo)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.Foo`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.62μs -> 1.27μs (27.9% faster)

def test_required_with_type_param_that_is_bool():
    """Test Required property with bool as type_param."""
    r = Required(bool)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.bool`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.52μs -> 1.19μs (27.4% faster)

def test_required_with_type_param_that_is_bytes():
    """Test Required property with bytes as type_param."""
    r = Required(bytes)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.bytes`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.44μs -> 1.16μs (24.0% faster)

def test_required_with_type_param_that_is_list():
    """Test Required property with list as type_param."""
    r = Required(list)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.list`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.49μs -> 1.15μs (29.1% faster)

def test_required_with_type_param_that_is_tuple():
    """Test Required property with tuple as type_param."""
    r = Required(tuple)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.tuple`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.49μs -> 1.15μs (30.1% faster)

def test_required_with_type_param_that_is_set():
    """Test Required property with set as type_param."""
    r = Required(set)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.set`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.44μs -> 1.17μs (23.5% faster)

def test_required_with_type_param_that_is_dict():
    """Test Required property with dict as type_param."""
    r = Required(dict)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.dict`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.41μs -> 1.20μs (17.4% faster)

# 3. Large Scale Test Cases

def test_many_required_properties_unique_types():
    """Test with many Required properties with unique type_param values."""
    class DummyTypeBase: pass
    required_props = []
    expected_links = []
    # Create 500 unique DummyType classes
    for i in range(500):
        DummyType = type(f"DummyType{i}", (), {})
        r = Required(DummyType)
        required_props.append(r)
        expected_links.append(f":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.DummyType{i}`\\ )")
    # Check all links
    for r, expected in zip(required_props, expected_links):
        codeflash_output = _sphinx_type_link(r) # 221μs -> 199μs (10.8% faster)

def test_many_required_properties_same_type():
    """Test with many Required properties with the same type_param value."""
    required_props = [Required(int) for _ in range(500)]
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.int`\\ )"
    for r in required_props:
        codeflash_output = _sphinx_type_link(r) # 215μs -> 194μs (10.9% faster)

def test_deeply_nested_required_properties():
    """Test deeply nested Required properties."""
    # Required(Required(Required(int)))
    r1 = Required(int)
    r2 = Required(r1)
    r3 = Required(r2)
    expected_r1 = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.int`\\ )"
    expected_r2 = f":class:`~bokeh.core.properties.Required`\\ ({expected_r1})"
    expected_r3 = f":class:`~bokeh.core.properties.Required`\\ ({expected_r2})"
    codeflash_output = _sphinx_type_link(r3) # 1.70μs -> 1.52μs (11.9% faster)

def test_large_required_with_large_type_param_list():
    """Test Required property with a list of many elements as type_param."""
    # The type_param is a list, so property_link(list) is used
    big_list = [i for i in range(999)]
    r = Required(big_list)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.list`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.64μs -> 1.31μs (24.6% faster)

def test_large_required_with_large_type_param_dict():
    """Test Required property with a dict of many elements as type_param."""
    big_dict = {str(i): i for i in range(999)}
    r = Required(big_dict)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.dict`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.71μs -> 1.25μs (37.4% faster)

def test_large_required_with_large_type_param_set():
    """Test Required property with a set of many elements as type_param."""
    big_set = set(range(999))
    r = Required(big_set)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.set`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.89μs -> 1.37μs (37.9% faster)

def test_large_required_with_large_type_param_tuple():
    """Test Required property with a tuple of many elements as type_param."""
    big_tuple = tuple(range(999))
    r = Required(big_tuple)
    expected = ":class:`~bokeh.core.properties.Required`\\ (:class:`~bokeh.core.properties.tuple`\\ )"
    codeflash_output = _sphinx_type_link(r) # 1.80μs -> 1.30μ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-_sphinx_type_link-mhx0f92h and push.