⚡️ Speed up function make_index by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for make_index in panel/io/convert.py

⏱️ Runtime : 4.39 milliseconds → 4.04 milliseconds (best of 167 runs)

📝 Explanation and details

The optimized version achieves an 8% speedup through two key optimizations:

1. Avoiding tuple creation during sorting: The original code uses sorted(files.items()) which creates a temporary list of (label, filepath) tuples, then iterates through them. The optimized version uses sorted(files) to sort just the keys, then accesses files[label] directly. This eliminates the overhead of creating and unpacking tuples.

2. Local variable caching: The optimized code assigns os.path.basename to the local variable basename before the dictionary comprehension. This avoids repeated attribute lookups during iteration, as accessing local variables is faster than module attribute access in Python.

Performance characteristics: The optimization is most effective for larger dictionaries, as shown in the test results where cases with 500-1000 files see 10-13% improvements, while smaller cases show minimal or slightly negative impact due to the overhead of the local variable assignment. This explains why small test cases are slightly slower (1-6%) but larger workloads benefit significantly.

The changes preserve all functionality while reducing both memory allocation (no tuple creation) and lookup overhead (cached basename function).

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import os

# imports
import pytest
from panel.io.convert import make_index

# --- Begin: Minimal stubs for external dependencies to allow testing ---

# Simulate the CDN_DIST constant
CDN_DIST = "https://cdn.jsdelivr.net/npm/@holoviz/panel@latest/dist/"

# Simulate a minimal Jinja2-like template with a .render() method
class DummyTemplate:
    def render(self, **kwargs):
        # For testing, just return the dictionary for inspection
        return kwargs

# The INDEX_TEMPLATE object used by make_index
INDEX_TEMPLATE = DummyTemplate()
from panel.io.convert import make_index

# --- Unit tests ---

# 1. Basic Test Cases

def test_single_file_default_manifest():
    # Single file, default manifest True
    files = {'main': '/path/to/main.html'}
    codeflash_output = make_index(files); result = codeflash_output # 29.4μs -> 31.4μs (6.46% slower)

def test_multiple_files_with_title():
    # Multiple files, custom title
    files = {'a': '/foo/a.html', 'b': '/bar/b.html'}
    title = "My Title"
    codeflash_output = make_index(files, title=title); result = codeflash_output # 29.7μs -> 30.1μs (1.30% slower)

def test_manifest_false():
    # Manifest is False disables manifest, favicon, apple_icon
    files = {'main': '/path/to/main.html'}
    codeflash_output = make_index(files, manifest=False); result = codeflash_output # 27.6μs -> 28.3μs (2.51% slower)

def test_empty_files_dict():
    # Empty files dict returns empty items
    files = {}
    codeflash_output = make_index(files); result = codeflash_output # 24.5μs -> 25.3μs (3.12% slower)

def test_filename_with_no_path():
    # File is just a name, no path
    files = {'file': 'file.html'}
    codeflash_output = make_index(files); result = codeflash_output # 27.3μs -> 27.5μs (0.601% slower)

def test_filename_with_complex_path():
    # File has a complex path
    files = {'x': '/a/b/c/d/e.html'}
    codeflash_output = make_index(files); result = codeflash_output # 26.6μs -> 27.4μs (2.83% slower)

# 2. Edge Test Cases

def test_label_sorting():
    # Labels should be sorted alphabetically
    files = {'z': '/foo/z.html', 'a': '/foo/a.html', 'm': '/foo/m.html'}
    codeflash_output = make_index(files); result = codeflash_output # 28.6μs -> 29.0μs (1.37% slower)

def test_files_with_same_basename():
    # Different labels, same file basename
    files = {'first': '/foo/index.html', 'second': '/bar/index.html'}
    codeflash_output = make_index(files); result = codeflash_output # 28.5μs -> 28.5μs (0.025% faster)

def test_files_with_special_characters():
    # Filenames with spaces and unicode
    files = {'spaced': '/foo/my file.html', 'unicode': '/foo/üñîçødë.html'}
    codeflash_output = make_index(files); result = codeflash_output # 28.5μs -> 29.4μs (3.27% slower)

def test_none_title_explicit():
    # Explicit title=None should still set title to None
    files = {'main': '/main.html'}
    codeflash_output = make_index(files, title=None); result = codeflash_output # 27.5μs -> 27.4μs (0.695% faster)

def test_empty_string_title():
    # Empty string title
    files = {'main': '/main.html'}
    codeflash_output = make_index(files, title=''); result = codeflash_output # 27.5μs -> 27.8μs (1.35% slower)

def test_manifest_non_boolean():
    # manifest argument is not strictly boolean (should treat truthy/falsy)
    files = {'main': '/main.html'}
    codeflash_output = make_index(files, manifest=[]); result = codeflash_output # 26.8μs -> 27.6μs (2.95% slower)
    codeflash_output = make_index(files, manifest="yes"); result2 = codeflash_output # 14.7μs -> 15.1μs (2.77% slower)

def test_files_with_dot_in_label():
    # Label contains a dot
    files = {'foo.bar': '/baz.html'}
    codeflash_output = make_index(files); result = codeflash_output # 24.8μs -> 25.0μs (0.807% slower)

def test_files_with_empty_label():
    # Empty label as key
    files = {'': '/empty.html'}
    codeflash_output = make_index(files); result = codeflash_output # 25.6μs -> 26.2μs (2.06% slower)

def test_files_with_empty_filename():
    # Empty string as filename
    files = {'empty': ''}
    codeflash_output = make_index(files); result = codeflash_output # 25.9μs -> 26.7μs (3.04% slower)

def test_files_with_dot_filename():
    # Filename is just a dot
    files = {'dot': '.'}
    codeflash_output = make_index(files); result = codeflash_output # 26.4μs -> 26.4μs (0.057% faster)

def test_files_with_slash_filename():
    # Filename is just a slash
    files = {'slash': '/'}
    codeflash_output = make_index(files); result = codeflash_output # 26.9μs -> 26.9μs (0.067% slower)

# 3. Large Scale Test Cases

def test_many_files():
    # Test with 1000 files
    files = {f'file{i}': f'/dir/subdir/file{i}.html' for i in range(1000)}
    codeflash_output = make_index(files); result = codeflash_output # 582μs -> 528μs (10.2% faster)
    # Check a few spot values
    for i in [0, 10, 999]:
        label = f'file{i}'

def test_long_labels_and_filenames():
    # Test with long labels and filenames
    long_label = 'l' * 255
    long_filename = '/' + 'd' * 100 + '/f' * 100 + '.html'
    files = {long_label: long_filename}
    codeflash_output = make_index(files); result = codeflash_output # 29.8μs -> 30.1μs (1.14% slower)

def test_large_variety_of_paths():
    # Files in various nested directories
    files = {f'label{i}': f'/a/b/c/d/e/f/g/h/file{i}.html' for i in range(500)}
    codeflash_output = make_index(files); result = codeflash_output # 312μs -> 277μs (12.4% faster)
    for i in [0, 100, 499]:
        pass

def test_large_number_of_labels_with_sorting():
    # Ensure sorting with many unsorted labels
    files = {f'lbl{999-i:04d}': f'/f/file{999-i}.html' for i in range(1000)}
    codeflash_output = make_index(files); result = codeflash_output # 563μs -> 505μs (11.4% faster)
    # The first label should be 'lbl0000', last 'lbl0999'
    sorted_labels = sorted(files.keys())

def test_large_files_with_special_characters():
    # Many files with unicode and spaces in names
    files = {f'label{i}': f"/foo/üñîçødë file {i}.html" for i in range(500)}
    codeflash_output = make_index(files); result = codeflash_output # 320μs -> 293μs (9.34% faster)
    for i in [0, 250, 499]:
        expected = f'./üñîçødë file {i}.html'
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import os

# imports
import pytest  # used for our unit tests
from panel.io.convert import make_index


# Minimal stand-ins for external dependencies
class DummyTemplate:
    def render(self, **kwargs):
        # For testing, just return the kwargs dict for inspection
        return kwargs

CDN_DIST = "https://cdn.example.com/panel"
INDEX_TEMPLATE = DummyTemplate()
from panel.io.convert import make_index

# unit tests

# --- Basic Test Cases ---

def test_basic_single_file():
    # Test with a single file, manifest True
    files = {'main': '/path/to/main.html'}
    codeflash_output = make_index(files); result = codeflash_output # 30.5μs -> 31.1μs (2.01% slower)

def test_basic_multiple_files():
    # Multiple files, manifest True
    files = {'a': '/x/y/a.html', 'b': '/x/y/b.html'}
    codeflash_output = make_index(files, title="My Site"); result = codeflash_output # 30.5μs -> 29.2μs (4.28% faster)

def test_basic_manifest_false():
    # Manifest False disables manifest, favicon, apple_icon
    files = {'foo': '/tmp/foo.html'}
    codeflash_output = make_index(files, manifest=False); result = codeflash_output # 27.5μs -> 28.0μs (1.67% slower)

# --- Edge Test Cases ---

def test_empty_files_dict():
    # Empty files dict should return empty items
    codeflash_output = make_index({}); result = codeflash_output # 24.2μs -> 25.2μs (3.95% slower)

def test_files_with_non_html_extensions():
    # Files with various extensions
    files = {'img': '/var/img.png', 'doc': '/var/doc.pdf'}
    codeflash_output = make_index(files); result = codeflash_output # 28.3μs -> 28.4μs (0.342% slower)

def test_files_with_same_basename_different_paths():
    # Files with same name, different paths
    files = {'one': '/a/b/test.html', 'two': '/c/d/test.html'}
    codeflash_output = make_index(files); result = codeflash_output # 28.7μs -> 28.5μs (0.740% faster)

def test_files_with_special_characters():
    # Filenames with spaces and unicode
    files = {'spaced': '/tmp/file name.html', 'uni': '/tmp/файл.html'}
    codeflash_output = make_index(files); result = codeflash_output # 30.2μs -> 30.3μs (0.235% slower)

def test_files_with_empty_label_and_path():
    # Empty label and path
    files = {'': ''}
    codeflash_output = make_index(files); result = codeflash_output # 26.7μs -> 27.7μs (3.58% slower)

def test_files_with_dot_and_dotdot_paths():
    # Paths with '.' and '..'
    files = {'dot': './foo.html', 'dotdot': '../bar.html'}
    codeflash_output = make_index(files); result = codeflash_output # 28.0μs -> 28.5μs (1.56% slower)

def test_title_none_and_empty():
    # Title is None (default) and empty string
    files = {'main': '/x/main.html'}
    codeflash_output = make_index(files); result_none = codeflash_output # 26.4μs -> 27.4μs (3.60% slower)
    codeflash_output = make_index(files, title=""); result_empty = codeflash_output # 14.3μs -> 15.1μs (5.33% slower)

def test_files_dict_unsorted():
    # Dict order should not affect output, items sorted by label
    files = {'z': '/a/z.html', 'a': '/a/a.html', 'm': '/a/m.html'}
    codeflash_output = make_index(files); result = codeflash_output # 27.7μs -> 27.2μs (1.78% faster)

# --- Large Scale Test Cases ---

def test_large_number_of_files():
    # 1000 files, check performance and correctness
    files = {f'file{i}': f'/data/path/file{i}.html' for i in range(1000)}
    codeflash_output = make_index(files); result = codeflash_output # 578μs -> 517μs (11.8% faster)
    # Check a few random entries
    for i in [0, 499, 999]:
        label = f'file{i}'

def test_large_files_with_long_paths():
    # 1000 files with long, nested paths
    files = {f'long{i}': f'/very/long/path/{i}/subdir/file{i}.txt' for i in range(1000)}
    codeflash_output = make_index(files); result = codeflash_output # 576μs -> 512μs (12.5% faster)
    for i in [0, 500, 999]:
        label = f'long{i}'

def test_large_files_manifest_false():
    # 1000 files, manifest False
    files = {f'file{i}': f'/data/file{i}.html' for i in range(1000)}
    codeflash_output = make_index(files, manifest=False); result = codeflash_output # 590μs -> 518μs (13.9% faster)

# --- Negative/Failure Cases ---

def test_files_dict_with_non_string_keys_and_values():
    # Non-string keys/values should still work if os.path.basename can handle them
    files = {1: '/tmp/1.html', 2: '/tmp/2.html'}
    codeflash_output = make_index(files); result = codeflash_output # 31.2μs -> 31.9μs (2.16% slower)

def test_files_dict_with_none_path():
    # Path is None: os.path.basename(None) raises TypeError
    files = {'bad': None}
    with pytest.raises(TypeError):
        make_index(files) # 3.60μs -> 3.44μs (4.77% faster)

def test_files_dict_with_nonexistent_path_type():
    # Path is integer: os.path.basename(int) raises TypeError
    files = {'bad': 123}
    with pytest.raises(TypeError):
        make_index(files) # 3.60μs -> 3.60μs (0.111% 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-make_index-mhb2leaj and push.