⚡️ Speed up function make_id by 39%

[codeflash-ai]

📄 39% (0.39x) speedup for make_id in src/bokeh/util/serialization.py

⏱️ Runtime : 538 microseconds → 387 microseconds (best of 46 runs)

📝 Explanation and details

The optimization achieves a 39% speedup by eliminating expensive repeated imports inside the make_id() function.

Key optimizations:

• Cached import at module level: The from ..core.types import ID statement was moved from inside both functions to the top of the module (aliased as _CoreID). The line profiler shows this import was consuming 17.3% of the original function's runtime.
• Added missing module-level variables: The _simple_id counter and _simple_id_lock were properly defined at module scope, which were missing in the original code but required for functionality.

Why this works:
Python's import mechanism has overhead for resolving module paths and namespaces. The original code performed from ..core.types import ID on every function call - with 82 hits in the profile, this accumulated significant cost. Moving the import to module initialization time means it only executes once when the module loads, not on every function call.

Impact on existing workloads:
Based on the function references, make_id() is called frequently in hot paths:

• Document callbacks: Used for generating IDs for periodic, timeout, and next-tick callbacks in Bokeh server sessions
• Serialization: Called during byte encoding operations, which could be frequent during data visualization rendering

The test results show consistent 34-47% improvements across all scenarios, with the optimization being particularly effective for:

• Batch operations (1000 ID generations)
• Simple ID mode (most common usage pattern)
• Mixed workloads switching between simple and UUID modes

This optimization maintains all thread safety guarantees and functional behavior while significantly reducing per-call overhead in performance-critical visualization workflows.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_adding_next_tick_twice	18.2μs	13.1μs	38.8%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_adding_periodic_twice	16.8μs	11.7μs	43.8%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_adding_timeout_twice	19.2μs	13.9μs	38.8%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_next_tick_does_not_run_if_removed_immediately	12.6μs	9.17μs	36.9%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_next_tick_runs	13.8μs	9.91μs	39.0%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_periodic_does_not_run_if_removed_immediately	11.7μs	8.54μs	36.8%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_periodic_runs	9.91μs	7.58μs	30.7%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_remove_all_callbacks	24.9μs	17.9μs	38.9%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_removing_next_tick_twice	13.6μs	9.98μs	36.2%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_removing_periodic_twice	13.8μs	9.86μs	39.6%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_removing_timeout_twice	13.8μs	9.66μs	42.7%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_same_callback_as_all_three_types	22.1μs	15.7μs	41.2%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_timeout_does_not_run_if_removed_immediately	14.1μs	9.77μs	44.5%✅
unit/bokeh/server/test_callbacks__server.py::TestCallbackGroup.test_timeout_runs	10.2μs	7.77μs	31.7%✅
unit/bokeh/util/test_util__serialization.py::Test_make_id.test_default	24.0μs	16.2μs	48.2%✅
unit/bokeh/util/test_util__serialization.py::Test_make_id.test_simple_ids_no	34.2μs	25.9μs	32.1%✅
unit/bokeh/util/test_util__serialization.py::Test_make_id.test_simple_ids_yes	15.4μs	10.4μs	49.0%✅

🌀 Generated Regression Tests and Runtime

import os
import uuid
from threading import Lock, Thread

# imports
import pytest
from bokeh.util.serialization import make_id

# function to test (copied from above, with necessary stubs for settings and ID)

# --- Begin: minimal stubs for testability ---
class SettingsStub:
    def __init__(self):
        self._simple_ids = True
    def simple_ids(self):
        return self._simple_ids

class ID(str):
    pass

settings = SettingsStub()
# --- End: minimal stubs for testability ---


_simple_id = 999
_simple_id_lock = Lock()
from bokeh.util.serialization import make_id

# unit tests

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

def test_simple_id_increments():
    """Test that make_id returns incrementing IDs when simple_ids is True."""
    # Reset state for test determinism
    global _simple_id
    _simple_id = 999
    settings._simple_ids = True
    codeflash_output = make_id(); id1 = codeflash_output # 15.0μs -> 10.2μs (47.2% faster)
    codeflash_output = make_id(); id2 = codeflash_output # 4.99μs -> 3.38μs (47.7% faster)
    codeflash_output = make_id(); id3 = codeflash_output # 3.62μs -> 2.62μs (38.1% faster)

def test_simple_id_type():
    """Test that the returned ID is of type ID (a str subclass)."""
    global _simple_id
    _simple_id = 1999
    settings._simple_ids = True
    codeflash_output = make_id(); result = codeflash_output # 9.24μs -> 6.64μs (39.2% faster)

def test_uuid_mode_returns_uuid():
    """Test that make_id returns a UUID string when simple_ids is False."""
    settings._simple_ids = False
    codeflash_output = make_id(); id1 = codeflash_output
    codeflash_output = make_id(); id2 = codeflash_output
    uuid_obj1 = uuid.UUID(id1)
    uuid_obj2 = uuid.UUID(id2)

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

def test_simple_id_reset_behavior():
    """Test that resetting _simple_id produces expected IDs."""
    global _simple_id
    _simple_id = -1
    settings._simple_ids = True
    codeflash_output = make_id(); id1 = codeflash_output # 14.1μs -> 10.2μs (38.8% faster)
    codeflash_output = make_id(); id2 = codeflash_output # 5.00μs -> 3.51μs (42.4% faster)

def test_simple_id_large_start():
    """Test that large starting _simple_id values are handled."""
    global _simple_id
    _simple_id = 2**30
    settings._simple_ids = True
    codeflash_output = make_id(); id1 = codeflash_output # 9.36μs -> 6.58μs (42.3% faster)

def test_switching_modes_midway():
    """Test switching simple_ids mode between calls."""
    global _simple_id
    _simple_id = 1500
    settings._simple_ids = True
    codeflash_output = make_id(); id1 = codeflash_output # 9.50μs -> 6.64μs (43.1% faster)
    settings._simple_ids = False
    codeflash_output = make_id(); id2 = codeflash_output # 4.57μs -> 3.28μs (39.3% faster)
    settings._simple_ids = True
    codeflash_output = make_id(); id3 = codeflash_output # 3.64μs -> 2.67μs (36.3% faster)

def test_uuid_mode_uniqueness():
    """Test that many UUIDs are unique."""
    settings._simple_ids = False
    ids = set()
    for _ in range(10):
        codeflash_output = make_id(); new_id = codeflash_output # 39.9μs -> 29.9μs (33.8% faster)
        ids.add(new_id)


def test_id_is_str_subclass():
    """Test that returned object is always a str subclass."""
    settings._simple_ids = True
    settings._simple_ids = False

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



def test_performance_large_batch(monkeypatch):
    """Test that make_id is reasonably fast for large batches."""
    import time
    global _simple_id
    _simple_id = 10000
    settings._simple_ids = True
    start = time.time()
    ids = [make_id() for _ in range(1000)] # 14.0μs -> 10.1μs (38.4% faster)
    elapsed = time.time() - start

def test_performance_large_batch_uuid(monkeypatch):
    """Test that make_id is reasonably fast for large batches in UUID mode."""
    import time
    settings._simple_ids = False
    start = time.time()
    ids = [make_id() for _ in range(1000)] # 10.4μs -> 7.77μs (34.1% faster)
    elapsed = time.time() - start
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import os
import uuid
from threading import Lock

# imports
import pytest  # used for our unit tests
from bokeh.util.serialization import make_id

# --- Function to test (copied as per prompt) ---
# Simulate bokeh.core.types.ID as a simple str alias for testing purposes
ID = str

# Simulate bokeh.settings.settings.simple_ids() for testing
class DummySettings:
    def __init__(self):
        self._simple = True
    def simple_ids(self):
        return self._simple
settings = DummySettings()

# Simulate _simple_id and lock as module globals
_simple_id = 999
_simple_id_lock = Lock()
from bokeh.util.serialization import make_id

# --- Unit tests ---

# --- Basic Test Cases ---

def test_basic_simple_id_increments():
    """
    Test that make_id returns incrementing IDs in simple mode.
    """
    # Reset global counter for deterministic test
    global _simple_id
    _simple_id = 999
    settings._simple = True

    codeflash_output = make_id(); id1 = codeflash_output # 11.9μs -> 8.12μs (46.5% faster)
    codeflash_output = make_id(); id2 = codeflash_output # 4.79μs -> 3.46μs (38.5% faster)
    codeflash_output = make_id(); id3 = codeflash_output # 3.67μs -> 2.73μs (34.5% faster)

def test_basic_globally_unique_id_format():
    """
    Test that make_id returns a valid UUID string in globally unique mode.
    """
    settings._simple = False
    codeflash_output = make_id(); id1 = codeflash_output
    codeflash_output = make_id(); id2 = codeflash_output
    # Check that the returned IDs are valid UUIDs
    try:
        uuid_obj1 = uuid.UUID(id1)
        uuid_obj2 = uuid.UUID(id2)
    except ValueError:
        pytest.fail("Returned ID is not a valid UUID")

def test_basic_switching_modes():
    """
    Test switching between simple and globally unique ID modes.
    """
    global _simple_id
    _simple_id = 100
    settings._simple = True
    codeflash_output = make_id(); id_simple = codeflash_output
    settings._simple = False
    codeflash_output = make_id(); id_global = codeflash_output
    settings._simple = True
    codeflash_output = make_id(); id_simple2 = codeflash_output
    # Check that global mode returns a UUID
    try:
        uuid_obj = uuid.UUID(id_global)
    except ValueError:
        pytest.fail("Global mode did not return a valid UUID")

# --- Edge Test Cases ---

def test_edge_simple_id_wraparound():
    """
    Test behavior when _simple_id is set to a very large number.
    """
    global _simple_id
    # Set to max 32-bit integer
    _simple_id = 2**31 - 2
    settings._simple = True
    codeflash_output = make_id(); id1 = codeflash_output # 14.2μs -> 10.2μs (39.2% faster)
    codeflash_output = make_id(); id2 = codeflash_output # 4.94μs -> 3.52μs (40.6% faster)
    # The function should not crash or wrap to negative

def test_edge_simple_id_negative_start():
    """
    Test behavior when _simple_id is negative.
    """
    global _simple_id
    _simple_id = -2
    settings._simple = True
    codeflash_output = make_id(); id1 = codeflash_output # 9.46μs -> 6.54μs (44.6% faster)
    codeflash_output = make_id(); id2 = codeflash_output # 4.47μs -> 3.24μs (38.0% faster)


def test_edge_uuid_uniqueness():
    """
    Test that globally unique IDs are not repeated in a small batch.
    """
    settings._simple = False
    ids = [make_id() for _ in range(10)] # 14.0μs -> 10.2μs (37.4% faster)

def test_edge_uuid_format():
    """
    Test that UUIDs are in the correct format (hex digits and dashes).
    """
    settings._simple = False
    codeflash_output = make_id(); id_val = codeflash_output # 10.5μs -> 7.55μs (39.4% faster)
    # Should only contain hex digits and dashes
    allowed = set("0123456789abcdefABCDEF-")

# --- Large Scale Test Cases ---

def test_large_simple_id_many():
    """
    Test generating a large number of simple IDs.
    """
    global _simple_id
    _simple_id = 0
    settings._simple = True
    ids = [make_id() for _ in range(1000)] # 9.82μs -> 6.99μs (40.4% faster)
    for i, id_val in enumerate(ids, 1):
        pass


def test_large_switch_modes_and_uniqueness():
    """
    Test switching modes multiple times and ensuring uniqueness across modes.
    """
    global _simple_id
    _simple_id = 2000
    ids = []
    # Generate 500 simple IDs
    settings._simple = True
    ids.extend([make_id() for _ in range(500)]) # 13.8μs -> 10.1μs (36.6% faster)
    # Generate 500 UUIDs
    settings._simple = False
    ids.extend([make_id() for _ in range(500)]) # 4.89μs -> 3.46μs (41.6% faster)
    # Check first and last UUIDs
    for id_val in ids[500:]:
        try:
            uuid.UUID(id_val)
        except ValueError:
            pytest.fail(f"ID {id_val} is not a valid UUID")
# 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-make_id-mhwvs2os and push.