⚡️ Speed up function to_templated by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for to_templated in plotly/io/_templates.py

⏱️ Runtime : 59.6 milliseconds → 55.1 milliseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves an 8% speedup through several key optimizations focused on reducing algorithmic complexity and avoiding redundant operations:

Primary Optimization - Dictionary Lookup for Template Elements:
The most significant change replaces O(N) linear search with O(1) dictionary lookup in walk_push_to_template. Instead of using template_element_names.index(fig_el.name) to find template elements, it creates a name_to_index dictionary mapping element names to their indices. This eliminates expensive list scanning when processing compound array validators.

Batch Operations for Trace Extensions:
Rather than extending template traces one-by-one with append() in a while loop, the code calculates how many traces are needed (traces_needed) and uses extend() with a generator expression to add them all at once. This reduces function call overhead and is more efficient for bulk operations.

Early Termination in Emptiness Checks:
The trace emptiness detection switches from creating a full list comprehension [trace.to_plotly_json() == {"type": trace_type} for trace in traces] to a generator that breaks on the first non-empty trace. This provides early exit behavior, avoiding unnecessary JSON serialization calls.

Variable Hoisting and Reduced Lookups:
The code pre-computes templated_layout_template_data to avoid repeated attribute access in loops, and uses skip_set consistently instead of reassigning the skip variable, reducing variable allocation overhead.

These optimizations are particularly effective for test cases involving multiple traces with named elements or complex template structures, where the dictionary lookup and batch operations provide the most benefit. The performance gains scale with the number of template elements and traces being processed.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_core/test_graph_objs/test_template.py::TestToTemplated.test_move_layout_nested_properties	4.17ms	3.71ms	12.7%✅
test_core/test_graph_objs/test_template.py::TestToTemplated.test_move_layout_nested_properties_no_skip	4.80ms	4.29ms	11.8%✅
test_core/test_graph_objs/test_template.py::TestToTemplated.test_move_layout_nested_with_existing_template	3.91ms	3.43ms	14.3%✅
test_core/test_graph_objs/test_template.py::TestToTemplated.test_move_named_annotation_property	6.94ms	6.30ms	10.2%✅
test_core/test_graph_objs/test_template.py::TestToTemplated.test_move_nested_trace_properties	7.40ms	6.74ms	9.79%✅
test_core/test_graph_objs/test_template.py::TestToTemplated.test_move_nested_trace_properties_existing_traces	9.75ms	9.09ms	7.21%✅
test_core/test_graph_objs/test_template.py::TestToTemplated.test_move_unnamed_annotation_property	7.30ms	6.75ms	8.01%✅

🌀 Generated Regression Tests and Runtime

import copy

# imports
import pytest
from plotly.io._templates import to_templated


# Minimal stubs to allow testing without plotly
class DummyValidator:
    array_ok = False
    def __init__(self, array_ok=False):
        self.array_ok = array_ok

class CompoundValidator(DummyValidator):
    pass

class CompoundArrayValidator(DummyValidator):
    pass

# Dummy base type for figure/layout/trace
class BasePlotlyType:
    def __init__(self, **props):
        self._props = set(props.keys())
        for k, v in props.items():
            setattr(self, k, v)
    def __getitem__(self, key):
        return getattr(self, key)
    def __setitem__(self, key, value):
        setattr(self, key, value)
        if value is None:
            self._props.discard(key)
        else:
            self._props.add(key)
    def __contains__(self, key):
        return hasattr(self, key)
    def to_plotly_json(self):
        # For simplicity, just return dict of props
        d = {}
        for k in self._props:
            v = getattr(self, k)
            if isinstance(v, BasePlotlyType):
                d[k] = v.to_plotly_json()
            elif isinstance(v, list):
                d[k] = [el.to_plotly_json() if isinstance(el, BasePlotlyType) else el for el in v]
            else:
                d[k] = v
        return d
    def __repr__(self):
        return f"{self.__class__.__name__}({self.to_plotly_json()})"
    def _get_validator(self, prop):
        # For test purposes, decide validator type by prop name
        # "font" is compound, "annotations" is compound array, others are simple
        if prop == "font" or prop == "title":
            return CompoundValidator()
        elif prop == "annotations":
            return CompoundArrayValidator(array_ok=True)
        elif prop.endswith("s"):  # treat plural as array
            return CompoundArrayValidator(array_ok=True)
        else:
            return DummyValidator(array_ok=False)

class DummyTemplate(BasePlotlyType):
    def __init__(self, layout=None, data=None):
        super().__init__(layout=layout or BasePlotlyType(), data=data or {})
        self.layout = self['layout']
        self.data = self['data']

class DummyLayout(BasePlotlyType):
    def __init__(self, **props):
        # Always include a template object
        props.setdefault('template', DummyTemplate())
        super().__init__(**props)
        self.template = self['template']

class DummyTrace(BasePlotlyType):
    def __init__(self, type='scatter', name=None, **props):
        props['type'] = type
        if name is not None:
            props['name'] = name
        super().__init__(**props)
        self.type = self['type']
        self.name = getattr(self, 'name', None)

class DummyFigure(BasePlotlyType):
    def __init__(self, data=None, layout=None):
        super().__init__(data=data or [], layout=layout or DummyLayout())
        self.data = self['data']
        self.layout = self['layout']
from plotly.io._templates import to_templated

# unit tests

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




def test_basic_dict_input():
    # Basic: Accept dict input
    fig_dict = {
        "layout": {
            "font": {"size": 14, "family": "Times"},
            "title": {"text": "Hello"}
        },
        "data": [{"type": "scatter", "marker": {"color": "blue"}}]
    }
    codeflash_output = to_templated(fig_dict); templated_fig = codeflash_output # 15.3ms -> 14.8ms (3.93% faster)

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















#------------------------------------------------
import copy

# imports
import pytest
from plotly.io._templates import to_templated

# Minimal mock classes to simulate plotly structure for testing

class MockValidator:
    def __init__(self, array_ok=False):
        self.array_ok = array_ok

class CompoundValidator(MockValidator):
    pass

class CompoundArrayValidator(MockValidator):
    pass

class MockBasePlotlyType:
    def __init__(self, props=None, validators=None):
        self._props = set(props.keys()) if props else set()
        self._data = props if props else {}
        self._validators = validators if validators else {}
    def __getitem__(self, key):
        return self._data.get(key, None)
    def __setitem__(self, key, value):
        self._data[key] = value
        if value is not None:
            self._props.add(key)
        elif key in self._props:
            self._props.remove(key)
    def _get_validator(self, key):
        return self._validators.get(key, MockValidator())
    def to_plotly_json(self):
        # Used to simulate trace emptiness
        return {k: v for k, v in self._data.items() if v is not None}
    @property
    def name(self):
        return self._data.get("name", None)
    @name.setter
    def name(self, value):
        self._data["name"] = value

class MockTrace(MockBasePlotlyType):
    def __init__(self, trace_type="scatter", props=None, validators=None):
        super().__init__(props, validators)
        self.type = trace_type

class MockTemplate:
    def __init__(self):
        self.layout = MockBasePlotlyType(props={}, validators={})
        self.data = {}
        # For each trace type, store a list of traces
    def __getitem__(self, key):
        return getattr(self, key)
    def __setitem__(self, key, value):
        setattr(self, key, value)

class MockLayout(MockBasePlotlyType):
    def __init__(self, props=None, validators=None, template=None):
        super().__init__(props, validators)
        self.template = template if template else MockTemplate()

class MockFigure:
    def __init__(self, layout=None, data=None):
        self.layout = layout if layout else MockLayout()
        self.data = data if data else []
from plotly.io._templates import to_templated

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

# Basic Test Cases

To edit these changes git checkout codeflash/optimize-to_templated-mhg67n5u and push.