⚡️ Speed up function interp_palette by 46%

[codeflash-ai]

📄 46% (0.46x) speedup for interp_palette in src/bokeh/palettes.py

⏱️ Runtime : 9.92 milliseconds → 6.81 milliseconds (best of 109 runs)

📝 Explanation and details

The optimized code achieves a 45% speedup by eliminating object allocation overhead in the color interpolation pipeline. The key optimization replaces the expensive RGB(*args).to_hex() pattern with direct hex string construction.

Primary optimization - Object allocation elimination:

• Original bottleneck: Creating thousands of temporary RGB objects just to call .to_hex() (81.2% of runtime in profiler)
• Solution: New rgba_to_hex() function that directly converts RGBA values to hex strings, bypassing object creation entirely
• Impact: Reduces the final tuple generation from 30.6ms to 8.6ms per call

Secondary optimization - Array access patterns:

• to_rgba_array improvements: Replaced enumerate() with range(len()) and direct array indexing (rgba_array[i, 0] = rgba.r vs tuple assignment)
• Impact: Minor but measurable improvement in array population efficiency

Performance characteristics by test case:

• Large-scale interpolations see biggest gains: 62-118% faster for n≥500 (e.g., test_large_n_with_small_palette: 1.13ms → 693μs)
• Alpha channel handling particularly benefits: 10-21% faster for RGBA interpolations due to avoiding repeated alpha calculations in RGB objects
• Small palettes show modest gains: 3-8% faster, still beneficial due to reduced overhead

The optimization maintains identical output and error handling while dramatically reducing memory pressure from temporary object creation - a classic Python performance pattern where avoiding object allocation provides substantial speedups.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
unit/bokeh/test_palettes.py::test_interp_palette	353μs	321μs	10.0%✅

🌀 Generated Regression Tests and Runtime

from typing import Tuple

# imports
import pytest
from bokeh.palettes import interp_palette

# --- Unit Tests ---

# --- Basic Test Cases ---

def test_single_color_palette_n_1():
    # Single color, n=1 should return the same color
    palette = ("#ff0000",)
    codeflash_output = interp_palette(palette, 1); result = codeflash_output # 60.1μs -> 57.2μs (5.16% faster)

def test_single_color_palette_n_5():
    # Single color, n>1 should repeat the color
    palette = ("#00ff00",)
    codeflash_output = interp_palette(palette, 5); result = codeflash_output # 53.5μs -> 49.8μs (7.38% faster)

def test_two_color_palette_n_2():
    # Two colors, n=2 should return original colors
    palette = ("#000000", "#ffffff")
    codeflash_output = interp_palette(palette, 2); result = codeflash_output # 48.7μs -> 47.2μs (3.15% faster)

def test_two_color_palette_n_3():
    # Two colors, n=3 should interpolate middle color
    palette = ("#000000", "#ffffff")
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 50.0μs -> 47.3μs (5.78% faster)

def test_three_color_palette_n_5():
    # Three colors, n=5 should interpolate between them
    palette = ("#ff0000", "#00ff00", "#0000ff")
    codeflash_output = interp_palette(palette, 5); result = codeflash_output # 53.2μs -> 50.7μs (4.85% faster)

def test_named_colors():
    # Named colors should be supported
    palette = ("red", "green", "blue")
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 53.1μs -> 50.9μs (4.38% faster)

def test_hex_and_named_mix():
    # Mix of hex and named colors
    palette = ("#ff0000", "green", "#0000ff")
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 53.3μs -> 50.7μs (5.25% faster)

def test_alpha_channel_interpolation():
    # Test RGBA hex colors
    palette = ("#ff000080", "#00ff00ff")
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 55.4μs -> 49.0μs (13.2% faster)

# --- Edge Test Cases ---

def test_empty_palette_raises():
    # Empty palette should raise ValueError
    with pytest.raises(ValueError):
        interp_palette((), 5) # 939ns -> 1.06μs (11.7% slower)

def test_negative_n_raises():
    # Negative n should raise ValueError
    palette = ("#ff0000", "#00ff00")
    with pytest.raises(ValueError):
        interp_palette(palette, -1) # 885ns -> 853ns (3.75% faster)

def test_palette_with_invalid_color_string():
    # Invalid color string should raise ValueError
    palette = ("notacolor", "#00ff00")
    with pytest.raises(ValueError):
        interp_palette(palette, 2) # 11.8μs -> 12.3μs (3.96% slower)

def test_palette_with_invalid_hex_format():
    # Invalid hex string should raise ValueError
    palette = ("#gggggg", "#00ff00")
    with pytest.raises(ValueError):
        interp_palette(palette, 2) # 9.91μs -> 10.2μs (3.25% slower)

def test_palette_n_zero():
    # n=0 should return empty tuple
    palette = ("#ff0000", "#00ff00")
    codeflash_output = interp_palette(palette, 0); result = codeflash_output # 56.4μs -> 55.3μs (2.00% faster)

def test_palette_n_one():
    # n=1 should return the first color
    palette = ("#ff0000", "#00ff00", "#0000ff")
    codeflash_output = interp_palette(palette, 1); result = codeflash_output # 57.0μs -> 54.1μs (5.36% faster)

def test_palette_n_equals_palette_length():
    # n == len(palette) should return original palette
    palette = ("#ff0000", "#00ff00", "#0000ff")
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 54.4μs -> 52.1μs (4.40% faster)

def test_palette_n_less_than_palette_length():
    # n < len(palette) should interpolate and select colors
    palette = ("#ff0000", "#00ff00", "#0000ff")
    codeflash_output = interp_palette(palette, 2); result = codeflash_output # 50.9μs -> 48.8μs (4.31% faster)

def test_palette_with_alpha_all_zeros():
    # All colors fully transparent
    palette = ("#ff000000", "#00ff0000")
    codeflash_output = interp_palette(palette, 2); result = codeflash_output # 54.1μs -> 47.6μs (13.7% faster)

def test_palette_with_alpha_all_ones():
    # All colors fully opaque
    palette = ("#ff0000ff", "#00ff00ff")
    codeflash_output = interp_palette(palette, 2); result = codeflash_output # 48.0μs -> 45.9μs (4.38% faster)

def test_palette_with_mixed_alpha():
    # Interpolating between opaque and transparent
    palette = ("#ff0000ff", "#ff000000")
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 54.2μs -> 48.9μs (10.8% faster)

# --- Large Scale Test Cases ---

def test_large_palette_interpolation():
    # Large palette, moderate n
    palette = tuple(f"#{i:02x}{i:02x}{i:02x}" for i in range(0, 256, 32))  # 8 colors from black to white
    codeflash_output = interp_palette(palette, 100); result = codeflash_output # 168μs -> 122μs (37.0% faster)
    # Should be monotonic in brightness
    prev = int(result[0][1:3], 16)
    for color in result[1:]:
        curr = int(color[1:3], 16)
        prev = curr

def test_large_n_with_small_palette():
    # Small palette, large n
    palette = ("#ff0000", "#0000ff")
    codeflash_output = interp_palette(palette, 1000); result = codeflash_output # 1.13ms -> 693μs (62.9% faster)

def test_palette_with_varied_alpha_large_n():
    # Large n, interpolating alpha
    palette = ("#ff000080", "#00ff00ff", "#0000ff00")
    codeflash_output = interp_palette(palette, 500); result = codeflash_output # 1.02ms -> 470μs (118% faster)
    # Middle color should have alpha between 0 and 1
    mid_hex = result[250]

def test_palette_performance_reasonable():
    # Should not take excessive time for 1000 colors
    import time
    palette = ("#ff0000", "#00ff00", "#0000ff")
    start = time.time()
    codeflash_output = interp_palette(palette, 1000); result = codeflash_output # 1.14ms -> 696μs (64.4% faster)
    end = time.time()

def test_palette_all_same_color_large_n():
    # Palette of identical colors, large n
    palette = ("#123456", "#123456", "#123456")
    codeflash_output = interp_palette(palette, 500); result = codeflash_output # 593μs -> 380μs (56.0% faster)

def test_palette_gradient_monotonicity():
    # Palette from black to white, check monotonicity
    palette = ("#000000", "#ffffff")
    codeflash_output = interp_palette(palette, 100); result = codeflash_output # 160μs -> 115μs (39.3% faster)
    prev = int(result[0][1:3], 16)
    for color in result[1:]:
        curr = int(color[1:3], 16)
        prev = curr
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from typing import Tuple

# imports
import pytest
from bokeh.palettes import interp_palette

# --- Unit tests ---

# 1. BASIC TEST CASES

def test_interp_palette_identity():
    # Interpolating to the same length returns the same colors (for n == len(palette))
    palette = ("#ff0000", "#00ff00", "#0000ff")
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 52.6μs -> 49.9μs (5.39% faster)

def test_interp_palette_linear_rgb():
    # Interpolating between two colors with n=5
    palette = ("#000000", "#ffffff")
    codeflash_output = interp_palette(palette, 5); result = codeflash_output # 49.3μs -> 46.8μs (5.27% faster)
    # Should interpolate linearly between black and white
    expected = (
        "#000000",  # 0%
        "#3f3f3f",  # ~25%
        "#7f7f7f",  # ~50%
        "#bfbfbf",  # ~75%
        "#ffffff",  # 100%
    )

def test_interp_palette_named_colors():
    # Palette with named colors
    palette = ("red", "green", "blue")
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 53.0μs -> 48.9μs (8.41% faster)
    # Should match the hex equivalents
    expected = ("#ff0000", "#00ff00", "#0000ff")

def test_interp_palette_rgba_alpha():
    # Palette with alpha, interpolating between opaque and transparent
    palette = ("#ff000080", "#ff0000ff")  # semi-transparent red to opaque red
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 55.3μs -> 48.8μs (13.4% faster)
    # Should interpolate alpha channel
    # 0: alpha=128/255 ~0.5; 1: alpha=191/255 ~0.75; 2: alpha=255/255=1.0
    expected = (
        "#ff000080",  # alpha=128
        "#ff0000bf",  # alpha=191
        "#ff0000",    # alpha=255 (no alpha in hex)
    )

def test_interp_palette_single_color():
    # Palette with a single color, any n>0 should repeat that color
    palette = ("#123456",)
    for n in [1, 2, 5, 10]:
        codeflash_output = interp_palette(palette, n); result = codeflash_output # 128μs -> 118μs (8.66% faster)

def test_interp_palette_n_zero():
    # Interpolating to zero colors returns an empty tuple
    palette = ("#abcdef", "#fedcba")
    codeflash_output = interp_palette(palette, 0); result = codeflash_output # 38.3μs -> 39.3μs (2.62% slower)

# 2. EDGE TEST CASES

def test_interp_palette_empty_palette():
    # Should raise ValueError on empty palette
    with pytest.raises(ValueError):
        interp_palette((), 5) # 945ns -> 1.11μs (14.6% slower)

def test_interp_palette_negative_n():
    # Should raise ValueError for negative n
    palette = ("#000000", "#ffffff")
    with pytest.raises(ValueError):
        interp_palette(palette, -1) # 840ns -> 901ns (6.77% slower)

def test_interp_palette_palette_with_one_color_and_alpha():
    # Single color with alpha, n>1
    palette = ("#12345678",)
    codeflash_output = interp_palette(palette, 4); result = codeflash_output # 68.6μs -> 56.7μs (21.1% faster)

def test_interp_palette_palette_with_short_hex():
    # Palette with short hex codes
    palette = ("#f00", "#0f0", "#00f")
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 56.3μs -> 51.6μs (9.17% faster)
    expected = ("#ff0000", "#00ff00", "#0000ff")

def test_interp_palette_palette_with_short_hex_alpha():
    # Palette with short hex RGBA codes
    palette = ("#f008", "#0f0f")
    codeflash_output = interp_palette(palette, 2); result = codeflash_output # 52.2μs -> 47.7μs (9.24% faster)
    expected = ("#ff000008", "#00ff00ff")

def test_interp_palette_non_divisible_steps():
    # Palette with 3 colors, n=4 (not divisible)
    palette = ("#000000", "#888888", "#ffffff")
    codeflash_output = interp_palette(palette, 4); result = codeflash_output # 53.1μs -> 50.8μs (4.58% faster)
    # Should interpolate at fractions 0, 0.666..., 1.333..., 2
    expected = (
        "#000000",
        "#555555",
        "#aaaaaa",
        "#ffffff"
    )

def test_interp_palette_alpha_interpolation_to_transparent():
    # Interpolate from opaque to transparent
    palette = ("#0000ff", "#0000ff00")
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 54.4μs -> 48.5μs (12.2% faster)
    # 0: opaque, 1: alpha=127, 2: alpha=0
    expected = (
        "#0000ff",
        "#0000ff7f",
        "#0000ff00"
    )

def test_interp_palette_alpha_rounding_behavior():
    # Test rounding of alpha channel at 0.5 boundary
    palette = ("#ff00007f", "#ff000080")
    codeflash_output = interp_palette(palette, 3); result = codeflash_output # 53.8μs -> 48.3μs (11.3% faster)
    # Should interpolate alpha 127, 128, 128
    expected = (
        "#ff00007f",
        "#ff000080",
        "#ff000080"
    )

def test_interp_palette_invalid_color_string():
    # Should raise ValueError if invalid color string is given
    palette = ("#zzzzzz",)
    with pytest.raises(ValueError):
        interp_palette(palette, 2) # 10.5μs -> 11.1μs (5.61% slower)

def test_interp_palette_named_color_not_found():
    # Should raise ValueError if unknown named color is given
    palette = ("notacolor",)
    with pytest.raises(ValueError):
        interp_palette(palette, 1) # 9.41μs -> 10.1μs (6.63% slower)

# 3. LARGE SCALE TEST CASES

def test_interp_palette_large_palette_large_n():
    # Large palette, large n
    palette = tuple(f"#{i:02x}{i:02x}{i:02x}" for i in range(0, 256, 32))  # 0,32,...224,240
    n = 500
    codeflash_output = interp_palette(palette, n); result = codeflash_output # 618μs -> 403μs (53.5% faster)

def test_interp_palette_large_n_two_colors():
    # Two colors, n=1000
    palette = ("#000000", "#ffffff")
    n = 1000
    codeflash_output = interp_palette(palette, n); result = codeflash_output # 1.15ms -> 712μs (61.0% faster)
    # Middle value should be a mid-gray
    mid = result[n//2]

def test_interp_palette_large_palette_n_smaller():
    # Large palette, small n
    palette = tuple(f"#{i:02x}{i:02x}{i:02x}" for i in range(0, 256, 16))  # 16 colors
    n = 4
    codeflash_output = interp_palette(palette, n); result = codeflash_output # 78.8μs -> 74.5μs (5.80% faster)

def test_interp_palette_large_palette_n_equal():
    # Large palette, n == len(palette)
    palette = tuple(f"#{i:02x}{i:02x}{i:02x}" for i in range(0, 256, 8))  # 32 colors
    n = len(palette)
    codeflash_output = interp_palette(palette, n); result = codeflash_output # 130μs -> 113μs (14.5% faster)

def test_interp_palette_large_palette_with_alpha():
    # Palette with alpha, n=100
    palette = tuple(f"#ff0000{a:02x}" for a in range(0, 256, 25))  # Red, alpha 0,25,...250
    n = 100
    codeflash_output = interp_palette(palette, n); result = codeflash_output # 263μs -> 147μs (78.9% faster)

def test_interp_palette_performance():
    # This test checks that the function can handle 1000 colors in a reasonable time
    import time
    palette = tuple(f"#{i:02x}{i:02x}{i:02x}" for i in range(0, 256, 1))  # 256 colors
    n = 1000
    start = time.time()
    codeflash_output = interp_palette(palette, n); result = codeflash_output # 1.54ms -> 1.10ms (40.0% 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.
#------------------------------------------------
from bokeh.palettes import interp_palette
import pytest

def test_interp_palette():
    with pytest.raises(TypeError, match="Cannot\\ cast\\ array\\ data\\ from\\ dtype\\('O'\\)\\ to\\ dtype\\('float64'\\)\\ according\\ to\\ the\\ rule\\ 'safe'"):
        interp_palette('gray', 0)

def test_interp_palette_2():
    with pytest.raises(ValueError, match='palette\\ must\\ contain\\ at\\ least\\ one\\ color'):
        interp_palette((), 0)

def test_interp_palette_3():
    with pytest.raises(ValueError, match='requested\\ palette\\ length\\ cannot\\ be\\ negative'):
        interp_palette('', -1)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_5f34sbte/tmpjqz5isp5/test_concolic_coverage.py::test_interp_palette_2	1.24μs	1.27μs	-2.13%⚠️

To edit these changes git checkout codeflash/optimize-interp_palette-mhbgy4ed and push.