⚡️ Speed up method Resources.adjust_paths by 1,544%

[codeflash-ai]

📄 1,544% (15.44x) speedup for Resources.adjust_paths in panel/io/resources.py

⏱️ Runtime : 37.5 milliseconds → 2.28 milliseconds (best of 38 runs)

📝 Explanation and details

The optimization achieves a 1543% speedup by eliminating redundant operations and reducing attribute lookups in the hot path of adjust_paths.

Key optimizations applied:

1. Pre-computed attribute caching: Moved repeated attribute accesses (self.mode, config.npm_cdn, state.base_url, etc.) outside the loop into local variables, eliminating thousands of attribute lookups per call.

2. Conditional string replacements: Changed resource.replace('https://unpkg.com', npm_cdn) to only execute when 'https://unpkg.com' in resource, avoiding unnecessary string operations on 99%+ of resources.

3. Limited replace operations: Used replace(..., 1) to stop after the first occurrence for cases where only one replacement is needed.

4. Control flow optimization: Restructured mode checks using elif and pre-computed boolean flags (server_mode, cdn_mode) to reduce repeated comparisons.

5. Method reference caching: Cached new_resources.append as append to avoid repeated method lookups in the tight loop.

6. Tuple pre-computation: Created base_prefixes and css_scheme tuples outside the loop for faster startswith() operations.

Performance characteristics: The optimization is most effective for large batches of resources (500+ items showing 19x-25x speedup) where the loop overhead dominates. For small batches, gains are more modest (15-35%) but consistent. The optimization maintains identical functionality while dramatically reducing per-iteration overhead through better memory access patterns and fewer redundant operations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import os
import types
from pathlib import Path

# imports
import pytest
from panel.io.resources import Resources


# --- Minimal mocks for config, state, etc. ---
class DummyConfig:
    npm_cdn = "https://cdn.npmjs.com"

class DummyState:
    base_url = "/base/"
    rel_path = ""
    
config = DummyConfig()
state = DummyState()

# Minimal JS_VERSION, CDN_ROOT, CDN_URL, CDN_DIST, LOCAL_DIST
JS_VERSION = "1.2.3"
CDN_ROOT = "https://cdn.holoviz.org/panel/"
CDN_URL = f"{CDN_ROOT}{JS_VERSION}/"
CDN_DIST = f"{CDN_URL}dist/"
LOCAL_DIST = "static/extensions/panel/"
EXTENSION_CDN = {}
from panel.io.resources import Resources

# ------------------- UNIT TESTS -------------------

# ---------- 1. Basic Test Cases ----------

def test_basic_cdn_url_replacement():
    """
    Test that a resource with the npm_cdn prefix is replaced with the CDN_DIST prefix in CDN mode.
    """
    resources = Resources(mode="cdn")
    input_url = f"{config.npm_cdn}/@holoviz/panel@{JS_VERSION}/dist/myfile.js"
    expected = [f"{CDN_DIST}myfile.js"]
    codeflash_output = resources.adjust_paths([input_url]) # 29.6μs -> 25.4μs (16.3% faster)

def test_basic_unpkg_replacement():
    """
    Test that a resource with the 'https://unpkg.com' prefix is replaced with config.npm_cdn.
    """
    resources = Resources(mode="cdn")
    input_url = "https://unpkg.com/@holoviz/[email protected]/dist/myfile.js"
    expected = [f"{config.npm_cdn}/@holoviz/[email protected]/dist/myfile.js".replace(
        f"{config.npm_cdn}/@holoviz/panel@{JS_VERSION}/dist/", CDN_DIST)]
    codeflash_output = resources.adjust_paths([input_url]) # 24.7μs -> 21.3μs (15.9% faster)

def test_basic_server_mode_replacement():
    """
    Test that a CDN_DIST resource is replaced with LOCAL_DIST in server mode.
    """
    resources = Resources(mode="server")
    input_url = f"{CDN_DIST}myfile.js"
    expected = [f"{LOCAL_DIST}myfile.js"]
    codeflash_output = resources.adjust_paths([input_url]) # 24.2μs -> 19.8μs (21.8% faster)

def test_basic_css_version_suffix():
    """
    Test that a local CSS file gets a version suffix.
    """
    resources = Resources(mode="cdn")
    input_url = "static/myfile.css"
    expected = [f"static/myfile.css?v={JS_VERSION}"]
    codeflash_output = resources.adjust_paths([input_url]) # 26.6μs -> 20.8μs (27.7% faster)

def test_basic_non_css_no_version_suffix():
    """
    Test that a non-CSS file does not get a version suffix.
    """
    resources = Resources(mode="cdn")
    input_url = "static/myfile.js"
    expected = ["static/myfile.js"]
    codeflash_output = resources.adjust_paths([input_url]) # 26.4μs -> 20.5μs (28.9% faster)

# ---------- 2. Edge Test Cases ----------

def test_empty_resource_list():
    """
    Test that an empty resource list returns an empty list.
    """
    resources = Resources(mode="cdn")
    codeflash_output = resources.adjust_paths([]) # 14.3μs -> 18.5μs (22.3% slower)

def test_non_string_resource():
    """
    Test that non-string resources are stringified.
    """
    resources = Resources(mode="cdn")
    input_url = Path("static/myfile.css")
    expected = ["static/myfile.css?v=1.2.3"]
    codeflash_output = resources.adjust_paths([input_url]) # 29.5μs -> 23.5μs (25.4% faster)

def test_resource_with_base_url_and_rel_path():
    """
    Test that a resource starting with base_url and state.rel_path set is prefixed.
    """
    resources = Resources(mode="server")
    input_url = "/base/static/myfile.css"
    # Patch state.rel_path for this test
    old_rel_path = state.rel_path
    state.rel_path = "foo/bar"
    expected = ["foo/bar/static/myfile.css?v=1.2.3"]
    try:
        codeflash_output = resources.adjust_paths([input_url])
    finally:
        state.rel_path = old_rel_path

def test_resource_with_base_url_and_absolute_server():
    """
    Test that a resource starting with base_url in server mode and absolute=True is prefixed with root_url.
    """
    resources = Resources(mode="server", absolute=True, root_url="http://localhost:5006/")
    input_url = "/base/static/myfile.css"
    # Patch state.rel_path for this test
    old_rel_path = state.rel_path
    state.rel_path = ""
    expected = ["http://localhost:5006/static/myfile.css?v=1.2.3"]
    try:
        codeflash_output = resources.adjust_paths([input_url])
    finally:
        state.rel_path = old_rel_path

def test_resource_with_static_prefix_and_rel_path():
    """
    Test that a resource starting with 'static/' and state.rel_path set is prefixed.
    """
    resources = Resources(mode="server")
    input_url = "static/myfile.css"
    old_rel_path = state.rel_path
    state.rel_path = "myrel"
    expected = ["myrel/static/myfile.css?v=1.2.3"]
    try:
        codeflash_output = resources.adjust_paths([input_url])
    finally:
        state.rel_path = old_rel_path

def test_resource_with_static_prefix_and_absolute_server():
    """
    Test that a resource starting with 'static/' and absolute=True in server mode is prefixed with root_url.
    """
    resources = Resources(mode="server", absolute=True, root_url="http://localhost:5006/")
    input_url = "static/myfile.css"
    old_rel_path = state.rel_path
    state.rel_path = ""
    expected = ["http://localhost:5006/static/myfile.css?v=1.2.3"]
    try:
        codeflash_output = resources.adjust_paths([input_url])
    finally:
        state.rel_path = old_rel_path

def test_resource_with_http_prefix_and_css():
    """
    Test that a CSS file with an http(s) prefix does NOT get a version suffix.
    """
    resources = Resources(mode="cdn")
    input_url = "http://cdn.example.com/myfile.css"
    expected = ["http://cdn.example.com/myfile.css"]
    codeflash_output = resources.adjust_paths([input_url]) # 23.9μs -> 20.3μs (17.9% faster)

def test_resource_with_https_prefix_and_css():
    """
    Test that a CSS file with an https prefix does NOT get a version suffix.
    """
    resources = Resources(mode="cdn")
    input_url = "https://cdn.example.com/myfile.css"
    expected = ["https://cdn.example.com/myfile.css"]
    codeflash_output = resources.adjust_paths([input_url]) # 24.0μs -> 20.4μs (17.5% faster)

def test_resource_with_no_suffix():
    """
    Test that a resource with no file extension is left unchanged.
    """
    resources = Resources(mode="cdn")
    input_url = "static/myfile"
    expected = ["static/myfile"]
    codeflash_output = resources.adjust_paths([input_url]) # 26.7μs -> 20.1μs (32.9% faster)

def test_resource_with_multiple_transformations():
    """
    Test a resource that triggers multiple transformation rules.
    """
    resources = Resources(mode="server", absolute=True, root_url="http://localhost:5006/")
    # This resource will be:
    # - replaced from CDN_DIST to LOCAL_DIST
    # - stripped of base_url
    # - prefixed with root_url (since absolute=True)
    input_url = f"/base/{CDN_DIST}myfile.css"
    # Remove base_url, replace CDN_DIST with LOCAL_DIST, then add root_url and version suffix
    expected = [f"http://localhost:5006/{LOCAL_DIST}myfile.css?v={JS_VERSION}"]
    codeflash_output = resources.adjust_paths([input_url]) # 27.3μs -> 19.8μs (37.9% faster)

def test_resource_with_extension_cdn_mapping():
    """
    Test that EXTENSION_CDN mapping is used in CDN mode.
    """
    resources = Resources(mode="cdn")
    # Setup a fake EXTENSION_CDN mapping
    fake_dir = os.path.abspath("fake/extension/dist")
    EXTENSION_CDN[fake_dir] = "https://cdn.example.com/fake/"
    resource_path = os.path.join(fake_dir, "foo.js")
    expected = ["https://cdn.example.com/fake/foo.js"]
    try:
        codeflash_output = resources.adjust_paths([resource_path])
    finally:
        EXTENSION_CDN.clear()

def test_resource_with_weird_path_characters():
    """
    Test that paths with backslashes or mixed separators are handled.
    """
    resources = Resources(mode="cdn")
    input_url = f"{config.npm_cdn}/@holoviz/panel@{JS_VERSION}\\dist\\myfile.js"
    # Should replace with CDN_DIST and convert backslashes to forward slashes
    expected = [f"{CDN_DIST}myfile.js"]
    codeflash_output = resources.adjust_paths([input_url]) # 23.4μs -> 20.1μs (16.6% faster)

# ---------- 3. Large Scale Test Cases ----------

def test_large_number_of_resources():
    """
    Test performance and correctness with a large number of resources.
    """
    resources = Resources(mode="cdn")
    input_urls = [f"static/file{i}.css" for i in range(500)]
    expected = [f"static/file{i}.css?v={JS_VERSION}" for i in range(500)]
    codeflash_output = resources.adjust_paths(input_urls) # 4.12ms -> 201μs (1947% faster)

def test_large_number_of_mixed_resources():
    """
    Test performance and correctness with mixed resource types and transformations.
    """
    resources = Resources(mode="server", absolute=True, root_url="http://localhost:5006/")
    old_rel_path = state.rel_path
    state.rel_path = "rel"
    try:
        input_urls = []
        expected = []
        for i in range(250):
            # Some with base_url, some with static/, some with CDN_DIST
            input_urls.append(f"/base/static/file{i}.css")
            expected.append(f"rel/static/file{i}.css?v={JS_VERSION}")
            input_urls.append(f"static/file{i}.js")
            expected.append(f"rel/static/file{i}.js")
            input_urls.append(f"{CDN_DIST}file{i}.css")
            # In server mode, CDN_DIST replaced with LOCAL_DIST, then rel_path prefixed, versioned
            expected.append(f"rel/{LOCAL_DIST}file{i}.css?v={JS_VERSION}")
        codeflash_output = resources.adjust_paths(input_urls)
    finally:
        state.rel_path = old_rel_path

def test_large_scale_with_extension_cdn():
    """
    Test EXTENSION_CDN mapping with a large number of resources.
    """
    resources = Resources(mode="cdn")
    fake_dir = os.path.abspath("large/extension/dist")
    EXTENSION_CDN[fake_dir] = "https://cdn.example.com/large/"
    input_urls = [os.path.join(fake_dir, f"file{i}.js") for i in range(500)]
    expected = [f"https://cdn.example.com/large/file{i}.js" for i in range(500)]
    try:
        codeflash_output = resources.adjust_paths(input_urls)
    finally:
        EXTENSION_CDN.clear()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from pathlib import Path

# imports
import pytest
from panel.io.resources import Resources


# Minimal stubs and configuration to allow adjust_paths to run in isolation
class DummyConfig:
    npm_cdn = "https://cdn.npmjs.com"

class DummyState:
    base_url = "/base/"
    rel_path = ""
    
config = DummyConfig()
state = DummyState()

JS_VERSION = "1.2.3"
CDN_ROOT = "https://cdn.holoviz.org/panel/"
CDN_URL = f"{CDN_ROOT}{JS_VERSION}/"
CDN_DIST = f"{CDN_URL}dist/"
LOCAL_DIST = "static/extensions/panel/"
EXTENSION_CDN = {}
from panel.io.resources import Resources

# ------------------- UNIT TESTS -------------------

# ----------- BASIC TEST CASES -----------

def test_basic_cdn_url_conversion():
    """Test CDN url conversion for a basic resource path."""
    res = Resources(mode='cdn')
    input_paths = [f"{config.npm_cdn}/@holoviz/panel@{JS_VERSION}/dist/foo.js"]
    expected = [f"{CDN_DIST}foo.js"]
    codeflash_output = res.adjust_paths(input_paths) # 29.6μs -> 25.6μs (16.0% faster)

def test_basic_local_css_versioning():
    """Test that .css files get version suffix when not absolute URL."""
    res = Resources(mode='cdn')
    input_paths = ["static/foo.css"]
    expected = [f"static/foo.css?v={JS_VERSION}"]
    codeflash_output = res.adjust_paths(input_paths) # 27.5μs -> 21.0μs (30.8% faster)

def test_basic_absolute_css_no_suffix():
    """Test that .css files with http/https do not get version suffix."""
    res = Resources(mode='cdn')
    input_paths = ["https://cdn.site.com/foo.css"]
    expected = ["https://cdn.site.com/foo.css"]
    codeflash_output = res.adjust_paths(input_paths) # 24.0μs -> 20.1μs (19.9% faster)

def test_basic_unpkg_replacement():
    """Test that unpkg.com is replaced with config.npm_cdn."""
    res = Resources(mode='cdn')
    input_paths = ["https://unpkg.com/@holoviz/[email protected]/dist/bar.js"]
    expected = [f"{config.npm_cdn}/@holoviz/[email protected]/dist/bar.js"]
    codeflash_output = res.adjust_paths(input_paths) # 25.3μs -> 20.7μs (22.0% faster)

def test_basic_server_mode_conversion():
    """Test that CDN_DIST is replaced with LOCAL_DIST in server mode."""
    res = Resources(mode='server')
    input_paths = [f"{CDN_DIST}baz.js"]
    expected = [f"{LOCAL_DIST}baz.js"]
    codeflash_output = res.adjust_paths(input_paths) # 23.2μs -> 19.2μs (20.5% faster)

def test_basic_non_string_resource():
    """Test that non-string resource is converted to string."""
    res = Resources(mode='cdn')
    input_paths = [Path("static/foo.css")]
    expected = [f"static/foo.css?v={JS_VERSION}"]
    codeflash_output = res.adjust_paths(input_paths) # 29.8μs -> 23.0μs (29.6% faster)

# ----------- EDGE TEST CASES -----------

def test_edge_empty_resource_list():
    """Test that empty resource list returns empty list."""
    res = Resources(mode='cdn')
    codeflash_output = res.adjust_paths([]) # 14.0μs -> 18.4μs (24.0% slower)

def test_edge_base_url_handling():
    """Test that resource starting with base_url is stripped and rel_path applied."""
    res = Resources(mode='server')
    state.base_url = "/base/"
    state.rel_path = "rel"
    input_paths = ["/base/static/foo.css"]
    expected = ["rel/static/foo.css?v={}".format(JS_VERSION)]
    codeflash_output = res.adjust_paths(input_paths) # 27.4μs -> 20.7μs (32.3% faster)
    state.rel_path = ""  # Reset after test

def test_edge_absolute_server_mode():
    """Test absolute path handling in server mode with absolute=True."""
    res = Resources(mode='server', absolute=True, root_url="https://host/")
    state.base_url = "/base/"
    input_paths = ["/base/static/foo.css"]
    expected = ["https://host/static/foo.css?v={}".format(JS_VERSION)]
    codeflash_output = res.adjust_paths(input_paths) # 27.6μs -> 20.2μs (36.8% faster)

def test_edge_extension_cdn_mapping():
    """Test EXTENSION_CDN mapping for subpath replacement."""
    EXTENSION_CDN.clear()
    EXTENSION_CDN["/ext/dist"] = "https://cdn.site.com/ext/"
    res = Resources(mode='cdn')
    input_paths = ["/ext/dist/foo.js"]
    expected = ["https://cdn.site.com/ext/foo.js"]
    codeflash_output = res.adjust_paths(input_paths) # 26.9μs -> 20.5μs (31.4% faster)
    EXTENSION_CDN.clear()  # Reset after test

def test_edge_resource_with_multiple_replacements():
    """Test resource needing multiple replacements (unpkg, cdn_base, css)."""
    res = Resources(mode='cdn')
    input_paths = [f"https://unpkg.com/@holoviz/panel@{JS_VERSION}/dist/foo.css"]
    # unpkg replaced with config.npm_cdn, cdn_base replaced with CDN_DIST, css gets version
    expected = [f"{CDN_DIST}foo.css?v={JS_VERSION}"]
    codeflash_output = res.adjust_paths(input_paths) # 24.2μs -> 21.0μs (15.4% faster)

def test_edge_resource_no_replacements():
    """Test resource that does not match any replacement logic."""
    res = Resources(mode='cdn')
    input_paths = ["foo.js"]
    expected = ["foo.js"]
    codeflash_output = res.adjust_paths(input_paths) # 23.8μs -> 20.1μs (18.5% faster)

def test_edge_resource_with_state_base_url_and_no_rel_path():
    """Test resource starting with base_url and no rel_path."""
    res = Resources(mode='server')
    state.base_url = "/base/"
    state.rel_path = ""
    input_paths = ["/base/static/foo.css"]
    expected = ["static/foo.css?v={}".format(JS_VERSION)]
    codeflash_output = res.adjust_paths(input_paths) # 27.5μs -> 20.3μs (35.5% faster)

def test_edge_resource_with_state_base_url_and_rel_path():
    """Test resource starting with base_url and with rel_path."""
    res = Resources(mode='server')
    state.base_url = "/base/"
    state.rel_path = "myrel"
    input_paths = ["/base/static/foo.css"]
    expected = ["myrel/static/foo.css?v={}".format(JS_VERSION)]
    codeflash_output = res.adjust_paths(input_paths) # 27.0μs -> 20.1μs (34.2% faster)
    state.rel_path = ""  # Reset after test

def test_edge_resource_with_static_prefix():
    """Test resource starting with 'static/' prefix."""
    res = Resources(mode='server')
    input_paths = ["static/foo.css"]
    expected = ["static/foo.css?v={}".format(JS_VERSION)]
    codeflash_output = res.adjust_paths(input_paths) # 25.6μs -> 19.5μs (30.9% faster)

def test_edge_resource_with_non_css_extension():
    """Test resource ending with .js does not get version suffix."""
    res = Resources(mode='cdn')
    input_paths = ["static/foo.js"]
    expected = ["static/foo.js"]
    codeflash_output = res.adjust_paths(input_paths) # 26.4μs -> 20.0μs (32.5% faster)

def test_edge_resource_with_non_string_and_non_path():
    """Test resource that is an integer (should be converted to str)."""
    res = Resources(mode='cdn')
    input_paths = [12345]
    expected = ["12345"]
    codeflash_output = res.adjust_paths(input_paths) # 23.8μs -> 20.2μs (17.6% faster)

# ----------- LARGE SCALE TEST CASES -----------

def test_large_scale_many_resources():
    """Test handling of a large list of resources for performance and correctness."""
    res = Resources(mode='cdn')
    input_paths = [f"static/foo{i}.css" for i in range(500)]
    expected = [f"static/foo{i}.css?v={JS_VERSION}" for i in range(500)]
    codeflash_output = res.adjust_paths(input_paths) # 4.10ms -> 198μs (1963% faster)

def test_large_scale_mixed_resources():
    """Test handling of a large list of mixed resource types."""
    res = Resources(mode='cdn')
    input_paths = []
    expected = []
    for i in range(250):
        input_paths.append(f"static/foo{i}.css")
        expected.append(f"static/foo{i}.css?v={JS_VERSION}")
        input_paths.append(f"https://cdn.site.com/foo{i}.css")
        expected.append(f"https://cdn.site.com/foo{i}.css")
        input_paths.append(f"static/foo{i}.js")
        expected.append(f"static/foo{i}.js")
    codeflash_output = res.adjust_paths(input_paths) # 5.76ms -> 255μs (2155% faster)

def test_large_scale_extension_cdn_mapping():
    """Test EXTENSION_CDN mapping on large number of resources."""
    EXTENSION_CDN.clear()
    EXTENSION_CDN["/ext/dist"] = "https://cdn.site.com/ext/"
    res = Resources(mode='cdn')
    input_paths = [f"/ext/dist/foo{i}.js" for i in range(500)]
    expected = [f"https://cdn.site.com/ext/foo{i}.js" for i in range(500)]
    codeflash_output = res.adjust_paths(input_paths) # 4.51ms -> 193μs (2233% faster)
    EXTENSION_CDN.clear()

def test_large_scale_server_mode_conversion():
    """Test server mode conversion on large number of CDN_DIST resources."""
    res = Resources(mode='server')
    input_paths = [f"{CDN_DIST}foo{i}.js" for i in range(500)]
    expected = [f"{LOCAL_DIST}foo{i}.js" for i in range(500)]
    codeflash_output = res.adjust_paths(input_paths) # 3.07ms -> 117μs (2516% faster)

def test_large_scale_base_url_and_rel_path():
    """Test base_url and rel_path handling on large number of resources."""
    res = Resources(mode='server')
    state.base_url = "/base/"
    state.rel_path = "rel"
    input_paths = [f"/base/static/foo{i}.css" for i in range(500)]
    expected = [f"rel/static/foo{i}.css?v={JS_VERSION}" for i in range(500)]
    codeflash_output = res.adjust_paths(input_paths) # 4.53ms -> 188μs (2304% faster)
    state.rel_path = ""  # Reset after test
# 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-Resources.adjust_paths-mh9xeiko and push.