⚡️ Speed up function create_static_handler by 10%

[codeflash-ai]

📄 10% (0.10x) speedup for create_static_handler in panel/io/server.py

⏱️ Runtime : 1.06 milliseconds → 966 microseconds (best of 34 runs)

📝 Explanation and details

The optimized code achieves a 9% speedup through two key improvements:

1. Eliminated redundant string operations: The original code performed string concatenation twice - first assigning route = prefix, then using route += with a conditional expression. The optimized version constructs the route string directly in one operation within each branch, avoiding the intermediate assignment and reducing string manipulation overhead.

2. Cached attribute access: By storing app.static_path in a local variable static_path, the code avoids repeated attribute lookups on the app object. Attribute access in Python has overhead compared to local variable access.

Performance characteristics by test case:

• Best gains (15-28% faster): Cases where key == '/' benefit most from the streamlined route construction, especially with empty prefixes or falsy static_path values
• Moderate gains (5-10% faster): Non-root keys and large-scale scenarios with many iterations benefit from the cached static_path access
• Minimal impact: Very long strings show slight slowdown due to the overhead of the conditional branching, but this is rare in practice

The optimization is particularly effective for the common case where key == '/' (which occurs in ~118 out of 4237 calls based on profiler data), eliminating unnecessary string operations while maintaining identical functionality.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# imports
import pytest
from panel.io.server import create_static_handler


# Dummy handler classes to mimic Bokeh/Tornado behavior for testing
class StaticHandler:
    pass

class StaticFileHandler:
    pass
from panel.io.server import create_static_handler


# Dummy app class for testing
class DummyApp:
    def __init__(self, static_path):
        self.static_path = static_path

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

def test_basic_with_static_path_and_root_key():
    # Test with static_path set and key is "/"
    app = DummyApp(static_path="/var/www/static")
    codeflash_output = create_static_handler("/prefix", "/", app); result = codeflash_output # 1.16μs -> 994ns (16.7% faster)

def test_basic_with_static_path_and_nonroot_key():
    # Test with static_path set and key is not "/"
    app = DummyApp(static_path="/var/www/static")
    codeflash_output = create_static_handler("/prefix", "/foo", app); result = codeflash_output # 1.03μs -> 1.00μs (3.30% faster)

def test_basic_without_static_path_and_root_key():
    # Test with static_path None and key is "/"
    app = DummyApp(static_path=None)
    codeflash_output = create_static_handler("/prefix", "/", app); result = codeflash_output # 911ns -> 826ns (10.3% faster)

def test_basic_without_static_path_and_nonroot_key():
    # Test with static_path None and key is not "/"
    app = DummyApp(static_path=None)
    codeflash_output = create_static_handler("/prefix", "/foo", app); result = codeflash_output # 865ns -> 890ns (2.81% slower)

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

def test_edge_empty_prefix():
    # Empty prefix, static_path set
    app = DummyApp(static_path="/tmp/static")
    codeflash_output = create_static_handler("", "/", app); result = codeflash_output # 934ns -> 783ns (19.3% faster)

def test_edge_empty_key():
    # Empty key, static_path set
    app = DummyApp(static_path="/tmp/static")
    codeflash_output = create_static_handler("/prefix", "", app); result = codeflash_output # 902ns -> 860ns (4.88% faster)

def test_edge_key_with_trailing_slash():
    # Key with trailing slash, static_path None
    app = DummyApp(static_path=None)
    codeflash_output = create_static_handler("/prefix", "/foo/", app); result = codeflash_output # 907ns -> 898ns (1.00% faster)

def test_edge_prefix_with_trailing_slash():
    # Prefix with trailing slash, static_path None
    app = DummyApp(static_path=None)
    codeflash_output = create_static_handler("/prefix/", "/foo", app); result = codeflash_output # 879ns -> 900ns (2.33% slower)

def test_edge_key_is_slash_and_prefix_empty():
    # Key is "/" and prefix is empty, static_path None
    app = DummyApp(static_path=None)
    codeflash_output = create_static_handler("", "/", app); result = codeflash_output # 869ns -> 771ns (12.7% faster)

def test_edge_key_is_slash_and_prefix_is_slash():
    # Key is "/" and prefix is "/", static_path None
    app = DummyApp(static_path=None)
    codeflash_output = create_static_handler("/", "/", app); result = codeflash_output # 901ns -> 783ns (15.1% faster)

def test_edge_key_is_slash_and_prefix_is_double_slash():
    # Key is "/" and prefix is "//", static_path None
    app = DummyApp(static_path=None)
    codeflash_output = create_static_handler("//", "/", app); result = codeflash_output # 866ns -> 810ns (6.91% faster)


def test_edge_static_path_is_empty_string():
    # static_path is empty string (not None, but falsy)
    app = DummyApp(static_path="")
    codeflash_output = create_static_handler("/prefix", "/", app); result = codeflash_output # 1.19μs -> 1.02μs (17.2% faster)

def test_edge_static_path_is_false():
    # static_path is False (not None, but falsy)
    app = DummyApp(static_path=False)
    codeflash_output = create_static_handler("/prefix", "/", app); result = codeflash_output # 1.08μs -> 854ns (26.2% faster)

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

def test_large_scale_many_keys():
    # Test with many keys to ensure scalability
    app = DummyApp(static_path="/large/static")
    keys = [f"/key{i}" for i in range(1000)]  # 1000 keys
    for i, key in enumerate(keys):
        codeflash_output = create_static_handler("/prefix", key, app); result = codeflash_output # 265μs -> 243μs (9.19% faster)

def test_large_scale_long_prefix_and_key():
    # Test with very long prefix and key
    long_prefix = "/" + "a" * 500
    long_key = "/" + "b" * 400
    app = DummyApp(static_path="/long/static")
    codeflash_output = create_static_handler(long_prefix, long_key, app); result = codeflash_output # 1.21μs -> 1.35μs (10.5% slower)

def test_large_scale_many_apps():
    # Test with many different app instances
    for i in range(1000):
        app = DummyApp(static_path=f"/static/path/{i}")
        codeflash_output = create_static_handler("/prefix", "/foo", app); result = codeflash_output # 264μs -> 241μs (9.38% faster)

def test_large_scale_none_static_path_many_keys():
    # Test with static_path None and many keys
    app = DummyApp(static_path=None)
    keys = [f"/k{i}" for i in range(1000)]
    for i, key in enumerate(keys):
        codeflash_output = create_static_handler("/p", key, app); result = codeflash_output # 241μs -> 222μs (8.54% faster)

def test_large_scale_empty_key_and_prefix():
    # Test with empty key and prefix, repeated many times
    app = DummyApp(static_path=None)
    for _ in range(1000):
        codeflash_output = create_static_handler("", "", app); result = codeflash_output # 201μs -> 183μs (9.67% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import sys
import types

# imports
import pytest
# function to test
from bokeh.server.views.static_handler import StaticHandler
from panel.io.server import create_static_handler
from tornado.web import StaticFileHandler


# Mocks for StaticFileHandler and StaticHandler (since we don't want to import tornado/bokeh in tests)
class DummyStaticFileHandler:
    pass

class DummyStaticHandler:
    pass

# Dummy app class for testing
class DummyApp:
    def __init__(self, static_path):
        self.static_path = static_path
from panel.io.server import create_static_handler

# unit tests

# 1. Basic Test Cases
def test_basic_static_path_with_root_key():
    # Normal condition: static_path set, key is "/"
    app = DummyApp(static_path="/my/static")
    codeflash_output = create_static_handler("/prefix", "/", app); result = codeflash_output # 1.18μs -> 954ns (23.7% faster)

def test_basic_static_path_with_non_root_key():
    # Normal condition: static_path set, key is not "/"
    app = DummyApp(static_path="/assets")
    codeflash_output = create_static_handler("/base", "/foo", app); result = codeflash_output # 954ns -> 925ns (3.14% faster)

def test_basic_no_static_path_with_root_key():
    # static_path is None, key is "/"
    app = DummyApp(static_path=None)
    codeflash_output = create_static_handler("/api", "/", app); result = codeflash_output # 906ns -> 768ns (18.0% faster)

def test_basic_no_static_path_with_non_root_key():
    # static_path is None, key is not "/"
    app = DummyApp(static_path=None)
    codeflash_output = create_static_handler("/api", "/bar", app); result = codeflash_output # 855ns -> 835ns (2.40% faster)

# 2. Edge Test Cases
def test_edge_empty_prefix():
    # Empty prefix, static_path set
    app = DummyApp(static_path="/static")
    codeflash_output = create_static_handler("", "/", app); result = codeflash_output # 945ns -> 755ns (25.2% faster)

def test_edge_prefix_with_trailing_slash():
    # Prefix ends with slash, key not root
    app = DummyApp(static_path="/static")
    codeflash_output = create_static_handler("/prefix/", "/foo", app); result = codeflash_output # 1.01μs -> 940ns (7.34% faster)

def test_edge_key_is_empty_string():
    # Key is empty string (should not patch)
    app = DummyApp(static_path="/static")
    codeflash_output = create_static_handler("/prefix", "", app); result = codeflash_output # 904ns -> 853ns (5.98% faster)

def test_edge_key_is_slash_with_spaces():
    # Key is " / " (not exactly "/")
    app = DummyApp(static_path=None)
    codeflash_output = create_static_handler("/prefix", " / ", app); result = codeflash_output # 821ns -> 850ns (3.41% slower)

def test_edge_static_path_is_empty_string():
    # static_path is empty string (should still use StaticFileHandler)
    app = DummyApp(static_path="")
    codeflash_output = create_static_handler("/prefix", "/", app); result = codeflash_output # 1.05μs -> 843ns (24.7% faster)

def test_edge_static_path_is_falsey():
    # static_path is False (should still use StaticFileHandler)
    app = DummyApp(static_path=False)
    codeflash_output = create_static_handler("/prefix", "/", app); result = codeflash_output # 1.06μs -> 828ns (28.3% faster)


def test_edge_prefix_and_key_are_empty():
    # Both prefix and key empty
    app = DummyApp(static_path=None)
    codeflash_output = create_static_handler("", "", app); result = codeflash_output # 891ns -> 856ns (4.09% faster)

def test_edge_app_has_no_static_path_attr():
    # app does not have static_path attribute
    class NoStaticPathApp:
        pass
    app = NoStaticPathApp()
    with pytest.raises(AttributeError):
        create_static_handler("/prefix", "/", app) # 1.69μs -> 1.62μs (4.83% faster)

# 3. Large Scale Test Cases
def test_large_scale_many_unique_keys():
    # Test with many unique keys and static_path set
    app = DummyApp(static_path="/static")
    for i in range(100):
        key = f"/key{i}"
        codeflash_output = create_static_handler("/prefix", key, app); result = codeflash_output # 28.2μs -> 25.6μs (9.94% faster)

def test_large_scale_many_prefix_variations():
    # Test with many prefix variations and static_path None
    app = DummyApp(static_path=None)
    for i in range(100):
        prefix = f"/api{i}"
        codeflash_output = create_static_handler(prefix, "/", app); result = codeflash_output # 25.8μs -> 20.8μs (23.9% faster)

def test_large_scale_long_key_and_prefix():
    # Long key and prefix strings
    long_prefix = "/" + "p" * 250
    long_key = "/" + "k" * 250
    app = DummyApp(static_path="/static")
    codeflash_output = create_static_handler(long_prefix, long_key, app); result = codeflash_output # 1.07μs -> 1.13μs (4.71% slower)
    expected_route = f"{long_prefix}{long_key}/static/(.*)"

def test_large_scale_all_combinations():
    # All combinations of static_path (None, str), key ("/", "/foo"), prefix ("/a", "/b")
    static_paths = [None, "/static"]
    keys = ["/", "/foo"]
    prefixes = ["/a", "/b"]
    for static_path in static_paths:
        for key in keys:
            for prefix in prefixes:
                app = DummyApp(static_path)
                codeflash_output = create_static_handler(prefix, key, app); result = codeflash_output
                if static_path is not None:
                    expected_handler = DummyStaticFileHandler
                    expected_dict = {"path": static_path}
                else:
                    expected_handler = DummyStaticHandler
                    expected_dict = {}
                if key == "/":
                    expected_route = f"{prefix}/static/(.*)"
                else:
                    expected_route = f"{prefix}{key}/static/(.*)"
# 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-create_static_handler-mhbf1zg8 and push.