⚡️ Speed up method _Distplot.make_kde by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for _Distplot.make_kde in plotly/figure_factory/_distplot.py

⏱️ Runtime : 131 milliseconds → 125 milliseconds (best of 54 runs)

📝 Explanation and details

The optimized code achieves a 5% speedup through several targeted optimizations that reduce computational overhead and memory allocations:

Key Optimizations:

1. Improved X-coordinate generation: Instead of the nested list comprehension [start + x * (end - start) / 500 for x in range(500)], the optimized version pre-computes delta = (end - start) / 500 and uses [start + x * delta for x in range(500)]. This eliminates repeated division operations inside the loop.

2. Local variable hoisting: Frequently accessed attributes like self.histnorm == ALTERNATIVE_HISTNORM, self.bin_size, and self.hist_data are stored in local variables (histnorm_alt, bin_size, hist_data). This reduces attribute lookup overhead in the inner loops.

3. Function reference caching: scipy_stats.gaussian_kde is cached as scipy_gaussian_kde to avoid repeated module attribute lookups during KDE computation.

4. Single-pass curve assembly: The original code used two separate loops - one for computing KDE values and another for assembling the result dictionaries. The optimized version uses a single list comprehension to create all curve dictionaries in one pass, eliminating the need for pre-initializing curve = [None] * self.trace_number.

Performance Impact by Test Case:

• Small datasets (1-3 traces): 18-30% faster, benefiting most from reduced overhead
• Medium datasets (10-50 traces): 27-29% faster, showing good scaling with the optimizations
• Large datasets (1000+ points): 1-8% faster, where KDE computation dominates but optimizations still help

The optimizations are particularly effective for scenarios with multiple traces where the reduced per-trace overhead compounds across iterations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import math

# imports
import pytest  # used for our unit tests
# function to test
from plotly.figure_factory._distplot import ALTERNATIVE_HISTNORM, _Distplot

# Basic Test Cases

def test_single_trace_basic_kde():
    """Test KDE output for a single small trace with default settings."""
    hist_data = [[1, 2, 3, 4, 5]]
    histnorm = None
    group_labels = ['A']
    bin_size = [1]
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 325μs -> 274μs (18.7% faster)
    # Each curve should be a dict with expected keys
    curve_dict = kde_curve[0]

def test_multiple_traces_basic_kde():
    """Test KDE output for two traces with different data."""
    hist_data = [[1, 2, 3], [10, 12, 14]]
    histnorm = None
    group_labels = ['A', 'B']
    bin_size = [1, 2]
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 520μs -> 417μs (24.8% faster)

def test_histnorm_probability_applies_bin_size():
    """Test that histnorm=probability multiplies y by bin_size."""
    hist_data = [[1, 2, 3, 4, 5]]
    histnorm = ALTERNATIVE_HISTNORM
    group_labels = ['A']
    bin_size = [2]
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 286μs -> 240μs (19.3% faster)
    # The y values should be double what they would be with bin_size=1
    distplot2 = _Distplot(hist_data, None, group_labels, [1], curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot2.make_kde(); kde_curve2 = codeflash_output # 233μs -> 188μs (23.9% faster)
    # Compare y values at a few points
    for y1, y2 in zip(kde_curve[0]['y'], kde_curve2[0]['y']):
        pass

def test_colors_are_used_and_wrapped():
    """Test that colors are assigned and wrap if more traces than default colors."""
    hist_data = [[1,2,3],[4,5,6],[7,8,9],[10,11,12],[13,14,15],[16,17,18],[19,20,21],[22,23,24],[25,26,27],[28,29,30],[31,32,33]]
    histnorm = None
    group_labels = [str(i) for i in range(len(hist_data))]
    bin_size = [1]*len(hist_data)
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 2.39ms -> 1.85ms (28.9% faster)
    # There are 11 traces, colors should wrap after 10
    default_colors = [
        "rgb(31, 119, 180)",
        "rgb(255, 127, 14)",
        "rgb(44, 160, 44)",
        "rgb(214, 39, 40)",
        "rgb(148, 103, 189)",
        "rgb(140, 86, 75)",
        "rgb(227, 119, 194)",
        "rgb(127, 127, 127)",
        "rgb(188, 189, 34)",
        "rgb(23, 190, 207)",
    ]
    for i, curve in enumerate(kde_curve):
        pass

def test_custom_colors():
    """Test that custom colors are used and wrap as needed."""
    hist_data = [[1,2],[3,4],[5,6],[7,8]]
    histnorm = None
    group_labels = ['A','B','C','D']
    bin_size = [1,1,1,1]
    curve_type = 'kde'
    colors = ['red','green']
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 897μs -> 692μs (29.6% faster)
    for i, curve in enumerate(kde_curve):
        pass

def test_show_hist_affects_showlegend():
    """Test that show_hist affects showlegend in output dict."""
    hist_data = [[1,2,3]]
    histnorm = None
    group_labels = ['A']
    bin_size = [1]
    curve_type = 'kde'
    colors = None
    rug_text = None
    # When show_hist=True, showlegend should be False
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, True, True)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 264μs -> 220μs (19.8% faster)
    # When show_hist=False, showlegend should be True
    distplot2 = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, False, True)
    codeflash_output = distplot2.make_kde(); kde_curve2 = codeflash_output # 218μs -> 172μs (26.5% faster)

# Edge Test Cases

def test_empty_hist_data_raises_min_max():
    """Test that an empty trace raises ValueError on min/max."""
    hist_data = [[]]
    histnorm = None
    group_labels = ['A']
    bin_size = [1]
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    # Should raise ValueError when min/max is called on empty list
    with pytest.raises(ValueError):
        _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)

def test_single_value_hist_data():
    """Test KDE output for a single-value trace."""
    hist_data = [[42]]
    histnorm = None
    group_labels = ['A']
    bin_size = [1]
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output

def test_group_labels_length_mismatch():
    """Test that group_labels length mismatch raises IndexError."""
    hist_data = [[1,2,3],[4,5,6]]
    histnorm = None
    group_labels = ['A']  # Should be length 2
    bin_size = [1,1]
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    # Should raise IndexError when accessing group_labels in make_kde
    with pytest.raises(IndexError):
        distplot.make_kde() # 575μs -> 474μs (21.3% faster)

def test_bin_size_length_mismatch():
    """Test that bin_size length mismatch raises IndexError."""
    hist_data = [[1,2,3],[4,5,6]]
    histnorm = ALTERNATIVE_HISTNORM
    group_labels = ['A','B']
    bin_size = [1]  # Should be length 2
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    # Should raise IndexError when accessing bin_size in make_kde
    with pytest.raises(IndexError):
        distplot.make_kde() # 509μs -> 411μs (23.8% faster)

def test_colors_length_less_than_traces():
    """Test that colors shorter than number of traces wrap correctly and do not raise."""
    hist_data = [[1,2,3],[4,5,6],[7,8,9]]
    histnorm = None
    group_labels = ['A','B','C']
    bin_size = [1,1,1]
    curve_type = 'kde'
    colors = ['red']
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 709μs -> 572μs (23.9% faster)
    # All curves should have marker color 'red'
    for curve in kde_curve:
        pass

def test_rug_text_none_and_length_mismatch():
    """Test that rug_text is set to [None]*trace_number if None, and length mismatch does not affect make_kde."""
    hist_data = [[1,2,3],[4,5,6]]
    histnorm = None
    group_labels = ['A','B']
    bin_size = [1,1]
    curve_type = 'kde'
    colors = None
    rug_text = ['foo']  # Should be length 2 but only length 1
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 482μs -> 388μs (24.3% faster)

# Large Scale Test Cases

def test_large_trace_count():
    """Test KDE output for a large number of traces (up to 50)."""
    hist_data = [[i + j for j in range(10)] for i in range(50)]
    histnorm = None
    group_labels = [str(i) for i in range(50)]
    bin_size = [1]*50
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 12.1ms -> 9.48ms (27.2% faster)
    # Each curve's x should cover the correct range
    for i, curve in enumerate(kde_curve):
        pass

def test_large_data_per_trace():
    """Test KDE output for a trace with a large number of data points (up to 1000)."""
    hist_data = [list(range(1000))]
    histnorm = None
    group_labels = ['A']
    bin_size = [1]
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 4.30ms -> 4.25ms (1.32% faster)

def test_large_trace_and_data_combination():
    """Test KDE output for multiple traces each with large data (10 traces, 1000 points each)."""
    hist_data = [list(range(i*100, i*100+1000)) for i in range(10)]
    histnorm = None
    group_labels = [str(i) for i in range(10)]
    bin_size = [1]*10
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 42.3ms -> 41.7ms (1.49% faster)
    for i, curve in enumerate(kde_curve):
        pass

def test_performance_large_scale():
    """Test that large scale does not raise and completes in reasonable time (up to 1000 points, 10 traces)."""
    hist_data = [list(range(i, i+1000)) for i in range(10)]
    histnorm = None
    group_labels = [str(i) for i in range(10)]
    bin_size = [1]*10
    curve_type = 'kde'
    colors = None
    rug_text = None
    show_hist = True
    show_curve = True
    distplot = _Distplot(hist_data, histnorm, group_labels, bin_size, curve_type, colors, rug_text, show_hist, show_curve)
    codeflash_output = distplot.make_kde(); kde_curve = codeflash_output # 42.2ms -> 41.9ms (0.846% faster)
    for curve in kde_curve:
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import math

# imports
import pytest  # used for our unit tests
# function to test
from plotly import optional_imports
from plotly.figure_factory._distplot import _Distplot

scipy_stats = optional_imports.get_module("scipy.stats")
ALTERNATIVE_HISTNORM = "probability"
from plotly.figure_factory._distplot import _Distplot

# unit tests

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

def test_single_trace_basic():
    # Test with a single trace of normal data
    data = [[1, 2, 3, 4, 5]]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["group1"],
        bin_size=[1],
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 316μs -> 276μs (14.3% faster)
    # Each result should be a dict with expected keys
    curve_dict = result[0]
    for key in ["type", "x", "y", "xaxis", "yaxis", "mode", "name", "legendgroup", "showlegend", "marker"]:
        pass

def test_multiple_traces_basic():
    # Test with two traces of different ranges
    data = [[1, 2, 3], [10, 20, 30]]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["a", "b"],
        bin_size=[1, 2],
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=False,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 503μs -> 420μs (19.6% faster)

def test_colors_and_marker():
    # Test with custom colors
    data = [[1, 2, 3], [4, 5, 6]]
    colors = ["rgb(100,100,100)", "rgb(200,200,200)"]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["g1", "g2"],
        bin_size=[1, 1],
        curve_type="kde",
        colors=colors,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 508μs -> 405μs (25.5% faster)

def test_histnorm_probability():
    # Test with histnorm set to 'probability'
    data = [[1, 2, 3, 4]]
    bin_size = [2]
    dp = _Distplot(
        hist_data=data,
        histnorm="probability",
        group_labels=["g"],
        bin_size=bin_size,
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 279μs -> 230μs (21.3% faster)
    # The y values should be scaled by bin_size
    kde = scipy_stats.gaussian_kde(data[0])
    x_vals = [min(data[0]) + x * (max(data[0]) - min(data[0])) / 500 for x in range(500)]
    expected_y = [y * bin_size[0] for y in kde(x_vals)]
    # Compare a few points for scaling
    for i in [0, 100, 499]:
        pass

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

def test_single_point_trace():
    # KDE with a single repeated value should fail (scipy raises error)
    data = [[42]]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["single"],
        bin_size=[1],
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    with pytest.raises(Exception):
        dp.make_kde() # 83.6μs -> 36.0μs (132% faster)


def test_identical_values_trace():
    # KDE with all identical values should fail (scipy raises error)
    data = [[7, 7, 7, 7]]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["identical"],
        bin_size=[1],
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    with pytest.raises(Exception):
        dp.make_kde() # 231μs -> 184μs (25.0% faster)

def test_negative_values_trace():
    # Test with negative values in the trace
    data = [[-10, -5, 0, 5, 10]]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["neg"],
        bin_size=[1],
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 311μs -> 265μs (17.3% faster)

def test_mixed_type_data():
    # Test with float and int mixed
    data = [[1, 2.5, 3, 4.75, 5]]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["mixed"],
        bin_size=[1],
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 300μs -> 251μs (19.6% faster)

def test_min_max_order():
    # Trace where min > max after sort
    data = [[5, 1, 3]]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["order"],
        bin_size=[1],
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 285μs -> 234μs (21.6% faster)

def test_custom_rug_text():
    # Custom rug_text should not affect KDE output
    data = [[1, 2, 3]]
    rug_text = ["a", "b", "c"]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["rug"],
        bin_size=[1],
        curve_type="kde",
        colors=None,
        rug_text=[rug_text],
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 275μs -> 233μs (17.8% faster)

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

def test_large_trace():
    # Test with a large trace (1000 elements)
    data = [list(range(1000))]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["large"],
        bin_size=[1],
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 4.26ms -> 4.21ms (1.25% faster)

def test_many_traces():
    # Test with many traces (up to 10, each with 100 elements)
    data = [list(range(i, i + 100)) for i in range(0, 1000, 100)]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=[f"group{i}" for i in range(10)],
        bin_size=[1]*10,
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 6.14ms -> 5.64ms (8.85% faster)
    # Each trace should have correct x range
    for i in range(10):
        pass

def test_large_bin_size_probability():
    # Test with large bin_size and probability histnorm
    data = [list(range(100))]
    bin_size = [100]
    dp = _Distplot(
        hist_data=data,
        histnorm="probability",
        group_labels=["largebin"],
        bin_size=bin_size,
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 671μs -> 630μs (6.47% faster)
    # y values should be scaled up by bin_size
    kde = scipy_stats.gaussian_kde(data[0])
    x_vals = [min(data[0]) + x * (max(data[0]) - min(data[0])) / 500 for x in range(500)]
    expected_y = [y * bin_size[0] for y in kde(x_vals)]
    for i in [0, 100, 499]:
        pass

def test_large_trace_negative_values():
    # Large trace with negative values
    data = [list(range(-500, 500))]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["large_neg"],
        bin_size=[1],
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 4.25ms -> 4.19ms (1.40% faster)

def test_large_trace_float_values():
    # Large trace with float values
    data = [ [float(i) / 10 for i in range(1000)] ]
    dp = _Distplot(
        hist_data=data,
        histnorm="",
        group_labels=["large_float"],
        bin_size=[0.1],
        curve_type="kde",
        colors=None,
        rug_text=None,
        show_hist=True,
        show_curve=True,
    )
    codeflash_output = dp.make_kde(); result = codeflash_output # 4.26ms -> 4.20ms (1.43% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from plotly.figure_factory._distplot import _Distplot

def test__Distplot_make_kde():
    _Distplot.make_kde(_Distplot('', 0, 0, 0, 0, 0, 0, 0, 0))

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_grpsys06/tmpriqz__i3/test_concolic_coverage.py::test__Distplot_make_kde	1.41μs	3.25μs	-56.4%⚠️

To edit these changes git checkout codeflash/optimize-_Distplot.make_kde-mhg6xny4 and push.