⚡️ Speed up method Figure.add_scattergl by 10%

[codeflash-ai]

📄 10% (0.10x) speedup for Figure.add_scattergl in plotly/graph_objs/_figure.py

⏱️ Runtime : 54.9 milliseconds → 49.8 milliseconds (best of 19 runs)

📝 Explanation and details

The optimized code achieves a 10% speedup by implementing import caching to eliminate repeated module imports. The key optimization is replacing the per-call from plotly.graph_objs import Scattergl with a class-level cache that stores the Scattergl class after the first import.

Specific changes:

• Added a conditional check if not hasattr(self.__class__, "_Scattergl_cls") to only import on first call
• Cached the imported Scattergl class as self.__class__._Scattergl_cls
• Retrieved the cached class with Scattergl = self.__class__._Scattergl_cls

Why this optimization works:
In Python, module imports involve significant overhead including module lookup, attribute resolution, and namespace operations. The original code performed this expensive import on every add_scattergl() call. By caching the class reference at the class level, subsequent calls bypass the import machinery entirely, accessing the cached reference with simple attribute lookup.

Performance characteristics:
The optimization shows the strongest benefits for workloads with repeated add_scattergl() calls:

• Single calls: 11-17% faster (basic cases)
• Multiple traces: 16% faster (100 traces scenario)
• Large datasets: 3-5% faster (1000+ data points)

The optimization is most effective for scenarios involving many trace additions where the import overhead becomes a significant bottleneck relative to the actual trace creation work.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from plotly.graph_objs._figure import Figure

# Basic Test Cases

def test_add_scattergl_basic_xy():
    # Test adding a simple scattergl trace with x and y lists
    fig = Figure()
    fig.add_scattergl(x=[1, 2, 3], y=[4, 5, 6]) # 147μs -> 128μs (14.5% faster)
    trace = fig.data[0]

def test_add_scattergl_with_name_and_mode():
    # Test adding a scattergl trace with name and mode
    fig = Figure()
    fig.add_scattergl(x=[0, 1], y=[1, 0], name="Test Trace", mode="markers") # 167μs -> 148μs (13.2% faster)
    trace = fig.data[0]

def test_add_scattergl_multiple_traces():
    # Test adding multiple scattergl traces to the same figure
    fig = Figure()
    fig.add_scattergl(x=[1], y=[2], name="A") # 145μs -> 128μs (13.3% faster)
    fig.add_scattergl(x=[3], y=[4], name="B") # 121μs -> 107μs (13.5% faster)

def test_add_scattergl_with_marker_and_line():
    # Test marker and line dicts
    fig = Figure()
    fig.add_scattergl(x=[1,2], y=[3,4], marker={"color":"red"}, line={"width":2}) # 287μs -> 270μs (6.31% faster)
    trace = fig.data[0]

def test_add_scattergl_with_text():
    # Test text as string and as list
    fig = Figure()
    fig.add_scattergl(x=[1], y=[2], text="single text") # 144μs -> 128μs (12.3% faster)
    fig.add_scattergl(x=[3,4], y=[5,6], text=["a", "b"]) # 135μs -> 119μs (13.3% faster)

# Edge Test Cases

def test_add_scattergl_empty_x_and_y():
    # Adding a trace with empty lists for x and y
    fig = Figure()
    fig.add_scattergl(x=[], y=[]) # 128μs -> 113μs (13.5% faster)
    trace = fig.data[0]

def test_add_scattergl_x_and_y_none():
    # Adding a trace with x and y as None (should result in None or empty array)
    fig = Figure()
    fig.add_scattergl(x=None, y=None) # 89.7μs -> 80.1μs (11.9% faster)
    trace = fig.data[0]


def test_add_scattergl_with_customdata_and_ids():
    # Test customdata and ids arrays
    fig = Figure()
    fig.add_scattergl(x=[1,2], y=[3,4], customdata=["foo", "bar"], ids=["id1", "id2"]) # 176μs -> 159μs (10.9% faster)
    trace = fig.data[0]

def test_add_scattergl_with_invalid_fill():
    # Invalid fill value should raise error
    fig = Figure()
    with pytest.raises(ValueError):
        fig.add_scattergl(x=[1], y=[2], fill="invalid_fill") # 74.7μs -> 54.9μs (36.0% faster)

def test_add_scattergl_with_selectedpoints_empty():
    # selectedpoints as empty list means empty selection
    fig = Figure()
    fig.add_scattergl(x=[1,2], y=[3,4], selectedpoints=[]) # 153μs -> 137μs (11.7% faster)
    trace = fig.data[0]

def test_add_scattergl_with_selectedpoints_non_array():
    # selectedpoints as non-array disables selection styling
    fig = Figure()
    fig.add_scattergl(x=[1,2], y=[3,4], selectedpoints=None) # 137μs -> 121μs (12.6% faster)
    trace = fig.data[0]

def test_add_scattergl_with_opacity_and_visible():
    # Test opacity and visible flags
    fig = Figure()
    fig.add_scattergl(x=[1], y=[2], opacity=0.5, visible="legendonly") # 161μs -> 145μs (10.9% faster)
    trace = fig.data[0]

def test_add_scattergl_with_x0_dx_y0_dy():
    # Test x0/dx and y0/dy for linear space
    fig = Figure()
    fig.add_scattergl(x0=10, dx=2, y0=20, dy=5) # 142μs -> 124μs (14.6% faster)
    trace = fig.data[0]

def test_add_scattergl_with_hoverinfo_and_hovertext():
    # Test hoverinfo and hovertext
    fig = Figure()
    fig.add_scattergl(x=[1], y=[2], hoverinfo="x+y+text", hovertext="hover!") # 171μs -> 153μs (11.6% faster)
    trace = fig.data[0]


def test_add_scattergl_with_row_without_col():
    # row without col should raise ValueError
    fig = Figure()
    with pytest.raises(ValueError):
        fig.add_scattergl(x=[1], y=[2], row=1, col=None) # 74.6μs -> 52.6μs (41.7% faster)

def test_add_scattergl_with_col_without_row():
    # col without row should raise ValueError
    fig = Figure()
    with pytest.raises(ValueError):
        fig.add_scattergl(x=[1], y=[2], col=1, row=None) # 69.1μs -> 48.5μs (42.4% faster)

def test_add_scattergl_with_showlegend_false():
    # showlegend False should be set
    fig = Figure()
    fig.add_scattergl(x=[1], y=[2], showlegend=False) # 147μs -> 131μs (12.4% faster)
    trace = fig.data[0]

def test_add_scattergl_with_kwargs():
    # Test passing arbitrary kwargs (e.g. custom property)
    fig = Figure()
    fig.add_scattergl(x=[1], y=[2], customdatasrc="src1") # 147μs -> 125μs (17.2% faster)
    trace = fig.data[0]

# Large Scale Test Cases

def test_add_scattergl_large_xy():
    # Test with large x and y arrays
    N = 1000
    x = list(range(N))
    y = [i * 2 for i in range(N)]
    fig = Figure()
    fig.add_scattergl(x=x, y=y) # 2.25ms -> 2.14ms (5.30% faster)
    trace = fig.data[0]

def test_add_scattergl_large_customdata():
    # Test with large customdata array
    N = 1000
    fig = Figure()
    fig.add_scattergl(x=list(range(N)), y=list(range(N)), customdata=[str(i) for i in range(N)]) # 3.42ms -> 3.25ms (5.33% faster)
    trace = fig.data[0]

def test_add_scattergl_large_text():
    # Test with large text array
    N = 1000
    texts = [f"pt{i}" for i in range(N)]
    fig = Figure()
    fig.add_scattergl(x=list(range(N)), y=list(range(N)), text=texts) # 3.57ms -> 3.41ms (4.60% faster)
    trace = fig.data[0]

def test_add_scattergl_many_traces():
    # Test adding many traces to a figure
    fig = Figure()
    for i in range(100):
        fig.add_scattergl(x=[i, i+1], y=[i*2, i*2+1], name=f"trace{i}") # 12.0ms -> 10.3ms (16.4% faster)
    for i in range(100):
        pass

def test_add_scattergl_large_marker_size():
    # Test marker.size as large array
    N = 1000
    sizes = [i % 10 + 1 for i in range(N)]
    fig = Figure()
    fig.add_scattergl(x=list(range(N)), y=list(range(N)), marker={"size": sizes}) # 4.08ms -> 3.92ms (4.06% faster)
    trace = fig.data[0]

def test_add_scattergl_large_ids():
    # Test large ids array
    N = 1000
    ids = [f"id{i}" for i in range(N)]
    fig = Figure()
    fig.add_scattergl(x=list(range(N)), y=list(range(N)), ids=ids) # 3.41ms -> 3.29ms (3.55% faster)
    trace = fig.data[0]

def test_add_scattergl_large_selectedpoints():
    # Test selectedpoints as large array
    N = 1000
    selected = list(range(N))
    fig = Figure()
    fig.add_scattergl(x=list(range(N)), y=list(range(N)), selectedpoints=selected) # 2.44ms -> 2.36ms (3.44% faster)
    trace = fig.data[0]

def test_add_scattergl_large_fillcolor():
    # Test fillcolor with large array (should be accepted if valid color string)
    fig = Figure()
    fig.add_scattergl(x=[1,2,3], y=[4,5,6], fill="tozeroy", fillcolor="rgba(255,0,0,0.5)") # 204μs -> 185μs (10.3% faster)
    trace = fig.data[0]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest
from plotly.graph_objs._figure import Figure

# -----------------------------
# Unit tests for add_scattergl
# -----------------------------

# 1. Basic Test Cases

def test_add_scattergl_minimal_xy():
    # Test adding a minimal scattergl trace with x and y
    fig = Figure()
    fig.add_scattergl(x=[1, 2, 3], y=[4, 5, 6]) # 140μs -> 123μs (14.0% faster)
    trace = fig.data[0]

def test_add_scattergl_with_name_and_mode():
    # Test adding a scattergl trace with name and mode
    fig = Figure()
    fig.add_scattergl(x=[0, 1], y=[1, 0], name="Test Trace", mode="markers+lines") # 170μs -> 157μs (8.82% faster)
    trace = fig.data[0]

def test_add_scattergl_with_marker_and_line():
    # Test adding a scattergl trace with marker and line dicts
    fig = Figure()
    marker = {"color": "red", "size": 10}
    line = {"color": "blue", "width": 2}
    fig.add_scattergl(x=[0, 1], y=[1, 0], marker=marker, line=line) # 337μs -> 318μs (6.16% faster)
    trace = fig.data[0]

def test_add_scattergl_with_text():
    # Test adding a scattergl trace with text labels
    fig = Figure()
    fig.add_scattergl(x=[1, 2], y=[3, 4], text=["A", "B"]) # 160μs -> 140μs (14.2% faster)
    trace = fig.data[0]

def test_add_scattergl_returns_figure():
    # Test that add_scattergl returns the figure itself
    fig = Figure()
    codeflash_output = fig.add_scattergl(x=[1], y=[1]); out = codeflash_output # 131μs -> 118μs (11.6% faster)

# 2. Edge Test Cases

def test_add_scattergl_empty_x_and_y():
    # Test with empty x and y lists
    fig = Figure()
    fig.add_scattergl(x=[], y=[]) # 129μs -> 111μs (16.1% faster)
    trace = fig.data[0]

def test_add_scattergl_none_x_and_y():
    # Test with x=None and y=None (should be accepted and set as None)
    fig = Figure()
    fig.add_scattergl(x=None, y=None) # 93.6μs -> 80.1μs (17.0% faster)
    trace = fig.data[0]

def test_add_scattergl_x0_dx_y0_dy():
    # Test linear x and y using x0/dx and y0/dy
    fig = Figure()
    fig.add_scattergl(x0=10, dx=2, y0=5, dy=3) # 145μs -> 125μs (15.1% faster)
    trace = fig.data[0]

def test_add_scattergl_customdata_and_ids():
    # Test with customdata and ids
    fig = Figure()
    fig.add_scattergl(x=[1], y=[2], customdata=["meta"], ids=["id1"]) # 160μs -> 145μs (10.4% faster)
    trace = fig.data[0]

def test_add_scattergl_with_fill_and_fillcolor():
    # Test with fill and fillcolor
    fig = Figure()
    fig.add_scattergl(x=[0, 1], y=[0, 1], fill="tozeroy", fillcolor="rgba(0,255,0,0.5)") # 206μs -> 181μs (13.6% faster)
    trace = fig.data[0]

def test_add_scattergl_with_selectedpoints():
    # Test with selectedpoints as a list
    fig = Figure()
    fig.add_scattergl(x=[0, 1, 2], y=[1, 2, 3], selectedpoints=[1]) # 147μs -> 130μs (12.7% faster)
    trace = fig.data[0]

def test_add_scattergl_with_opacity_and_visible():
    # Test with opacity and visible
    fig = Figure()
    fig.add_scattergl(x=[1], y=[2], opacity=0.3, visible="legendonly") # 158μs -> 142μs (11.3% faster)
    trace = fig.data[0]

def test_add_scattergl_with_hovertemplate_and_texttemplate():
    # Test with hovertemplate and texttemplate
    fig = Figure()
    fig.add_scattergl(x=[1], y=[2], hovertemplate="X: %{x}", texttemplate="Y: %{y}") # 161μs -> 144μs (11.7% faster)
    trace = fig.data[0]



def test_add_scattergl_with_inconsistent_x_y_length():
    # Test that inconsistent x/y lengths are accepted (Plotly will pad/trim)
    fig = Figure()
    fig.add_scattergl(x=[1, 2, 3], y=[4]) # 143μs -> 126μs (12.8% faster)
    trace = fig.data[0]

def test_add_scattergl_with_none_and_empty_lists():
    # Test with a mix of None and empty lists for various fields
    fig = Figure()
    fig.add_scattergl(x=None, y=[], text=None, ids=[]) # 129μs -> 114μs (13.1% faster)
    trace = fig.data[0]


def test_add_scattergl_large_number_of_points():
    # Test adding a scattergl trace with a large number of points (up to 1000)
    N = 1000
    x = list(range(N))
    y = [i * 2 for i in range(N)]
    fig = Figure()
    fig.add_scattergl(x=x, y=y) # 2.25ms -> 2.16ms (3.85% faster)
    trace = fig.data[0]

def test_add_scattergl_many_traces():
    # Test adding many scattergl traces (up to 100)
    fig = Figure()
    for i in range(100):
        fig.add_scattergl(x=[i, i+1], y=[i*2, i*2+1], name=f"trace{i}") # 12.0ms -> 10.3ms (16.1% faster)
    for i, trace in enumerate(fig.data):
        pass

def test_add_scattergl_large_customdata_and_ids():
    # Test with large customdata and ids arrays
    N = 500
    fig = Figure()
    customdata = [f"meta{i}" for i in range(N)]
    ids = [f"id{i}" for i in range(N)]
    fig.add_scattergl(x=list(range(N)), y=list(range(N)), customdata=customdata, ids=ids) # 2.38ms -> 2.26ms (5.42% faster)
    trace = fig.data[0]

def test_add_scattergl_large_text_and_hovertext():
    # Test with large text and hovertext arrays
    N = 300
    fig = Figure()
    text = [f"text{i}" for i in range(N)]
    hovertext = [f"hover{i}" for i in range(N)]
    fig.add_scattergl(x=list(range(N)), y=list(range(N)), text=text, hovertext=hovertext) # 1.57ms -> 1.49ms (4.86% faster)
    trace = fig.data[0]

To edit these changes git checkout codeflash/optimize-Figure.add_scattergl-mhfwjfct and push.