⚡️ Speed up method StaticHandler.append_version by 107%

[codeflash-ai]

📄 107% (1.07x) speedup for StaticHandler.append_version in src/bokeh/server/views/static_handler.py

⏱️ Runtime : 7.89 milliseconds → 3.81 milliseconds (best of 80 runs)

📝 Explanation and details

The optimization introduces class-level caching to eliminate repeated dictionary creation and filesystem path resolution in the append_version method.

Key Change:

• Added a class attribute _static_path_cache that stores the dict(static_path=settings.bokehjs_path()) on first use
• This cache is checked with hasattr() and only created once per class

Why This Improves Performance:

1. Eliminates Repeated Dictionary Creation: The original code created dict(static_path=settings.bokehjs_path()) on every call to append_version(), which involves dictionary allocation and key-value assignment
2. Reduces Filesystem Path Resolution: settings.bokehjs_path() performs filesystem operations and path resolution - the profiler shows this dropped from 1035 calls to just 16 calls
3. Memory Allocation Savings: Reusing the same dictionary reference avoids garbage collection overhead from repeated allocations

Performance Impact:
The line profiler shows the bokehjs_path() function calls dropped dramatically (1035 → 16 calls), indicating successful caching. The optimization provides 107% speedup overall, with individual test cases showing 70-110% improvements.

Best For: Applications that frequently serve static files in production mode, where append_version() is called repeatedly for the same static path configuration. The cache has no impact in dev mode since the method returns early.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

🌀 Generated Regression Tests and Runtime

import pytest
from bokeh.server.views.static_handler import StaticHandler


# Function to test
def append_version(path: str, dev: bool = False, version: str = "123abc") -> str:
    """
    Appends a version string as a query parameter to the given path unless in dev mode.
    - path: The file path (string).
    - dev: If True, do not append version.
    - version: The version string to append (default: "123abc").
    Returns the path, possibly with "?v=version" appended.
    """
    if dev:
        return path
    else:
        return f"{path}?v={version}"

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























#------------------------------------------------
import pytest
from bokeh.server.views.static_handler import StaticHandler


# Function to test (standalone, minimal version for testing)
class DummySettings:
    def __init__(self, dev=False, path="static"):
        self.dev = dev
        self._path = path
    def bokehjs_path(self):
        return self._path

class DummyStaticFileHandler:
    @staticmethod
    def get_version(static_path_dict, path):
        # Simulate a version hash: hash of path + path string length
        # This is deterministic and unique for each path
        return str(abs(hash(path)) % 10000 + len(path))
from bokeh.server.views.static_handler import StaticHandler

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

def test_append_version_dev_mode_returns_path():
    # Basic: dev mode should return path unchanged
    StaticHandler.settings = DummySettings(dev=True)
    codeflash_output = StaticHandler.append_version("foo.js") # 23.3μs -> 13.7μs (70.7% faster)
    codeflash_output = StaticHandler.append_version("bar.css") # 11.4μs -> 5.93μs (92.1% faster)

def test_append_version_prod_mode_appends_version():
    # Basic: prod mode should append version string
    StaticHandler.settings = DummySettings(dev=False)
    path = "foo.js"
    codeflash_output = StaticHandler.append_version(path); result = codeflash_output # 20.1μs -> 10.7μs (88.6% faster)

def test_append_version_different_paths_unique_versions():
    # Basic: different paths should yield different version strings
    StaticHandler.settings = DummySettings(dev=False)
    path1 = "foo.js"
    path2 = "bar.js"
    codeflash_output = StaticHandler.append_version(path1); result1 = codeflash_output # 19.6μs -> 10.7μs (82.6% faster)
    codeflash_output = StaticHandler.append_version(path2); result2 = codeflash_output # 10.6μs -> 5.49μs (92.6% faster)
    # Extract version numbers
    v1 = result1.split("?v=")[-1]
    v2 = result2.split("?v=")[-1]

def test_append_version_same_path_same_version():
    # Basic: same path should yield same version string
    StaticHandler.settings = DummySettings(dev=False)
    path = "foo.js"
    codeflash_output = StaticHandler.append_version(path); result1 = codeflash_output # 18.7μs -> 9.95μs (88.4% faster)
    codeflash_output = StaticHandler.append_version(path); result2 = codeflash_output # 10.3μs -> 5.43μs (89.6% faster)

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


def test_append_version_path_with_query_string():
    # Edge: path already contains a query string
    StaticHandler.settings = DummySettings(dev=False)
    path = "foo.js?bar=1"
    codeflash_output = StaticHandler.append_version(path); result = codeflash_output # 19.7μs -> 10.2μs (92.2% faster)

def test_append_version_path_with_special_characters():
    # Edge: path contains special characters
    StaticHandler.settings = DummySettings(dev=False)
    path = "foo-@#$.js"
    codeflash_output = StaticHandler.append_version(path); result = codeflash_output # 19.5μs -> 9.98μs (95.8% faster)

def test_append_version_path_with_unicode():
    # Edge: path contains unicode characters
    StaticHandler.settings = DummySettings(dev=False)
    path = "файл.js"
    codeflash_output = StaticHandler.append_version(path); result = codeflash_output # 21.9μs -> 12.1μs (80.8% faster)

def test_append_version_path_is_none_raises():
    # Edge: path is None should raise TypeError
    StaticHandler.settings = DummySettings(dev=False)
    with pytest.raises(TypeError):
        StaticHandler.append_version(None) # 18.0μs -> 8.99μs (99.8% faster)

def test_append_version_path_is_integer_raises():
    # Edge: path is integer should raise TypeError
    StaticHandler.settings = DummySettings(dev=False)
    with pytest.raises(TypeError):
        StaticHandler.append_version(123) # 18.3μs -> 8.69μs (110% faster)

def test_append_version_path_is_bytes_raises():
    # Edge: path is bytes should raise TypeError
    StaticHandler.settings = DummySettings(dev=False)
    with pytest.raises(TypeError):
        StaticHandler.append_version(b"foo.js") # 18.3μs -> 9.11μs (101% faster)

def test_append_version_path_is_whitespace():
    # Edge: path is whitespace
    StaticHandler.settings = DummySettings(dev=False)
    path = "   "
    codeflash_output = StaticHandler.append_version(path); result = codeflash_output # 21.1μs -> 12.1μs (74.2% faster)

def test_append_version_path_is_slash():
    # Edge: path is a slash
    StaticHandler.settings = DummySettings(dev=False)
    path = "/"
    codeflash_output = StaticHandler.append_version(path); result = codeflash_output # 18.2μs -> 9.21μs (97.1% faster)

def test_append_version_path_with_multiple_dots():
    # Edge: path with multiple dots
    StaticHandler.settings = DummySettings(dev=False)
    path = "foo.bar.baz.js"
    codeflash_output = StaticHandler.append_version(path); result = codeflash_output # 19.8μs -> 11.0μs (79.7% faster)

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


def test_append_version_large_path_list_consistency():
    # Large scale: repeated calls with same path in a large list
    StaticHandler.settings = DummySettings(dev=False)
    path = "shared.js"
    results = [StaticHandler.append_version(path) for _ in range(1000)] # 19.1μs -> 10.2μs (86.9% faster)

def test_append_version_large_path_list_dev_mode():
    # Large scale: dev mode, repeated calls
    StaticHandler.settings = DummySettings(dev=True)
    path = "shared.js"
    results = [StaticHandler.append_version(path) for _ in range(1000)] # 19.3μs -> 9.92μs (94.5% 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-StaticHandler.append_version-mhbkp7td and push.