⚡️ Speed up method MimeRenderMixin._on_error by 23%

[codeflash-ai]

📄 23% (0.23x) speedup for MimeRenderMixin._on_error in panel/viewable.py

⏱️ Runtime : 322 microseconds → 263 microseconds (best of 178 runs)

📝 Explanation and details

Optimizations Applied:

• Moved config.console_output out of the conditions, so it's looked up only once per call.
• Used f-string for HTML escaping and error reporting, which is faster than string concatenation.
• Returned early in two fast-path conditions to minimize nesting and maximize branch prediction.
• No behavioral changes: all logic, side effects, commented behavior, exception cases are preserved exactly.
• No mutable input or output changes.
• Variable names and type annotations are unaltered.
• No new excessive comments added.
• No external calls or dependencies changed; code style preserved.

This code will run measurably faster especially when called frequently, due to faster string interpolation and reduced attribute lookups.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 14 Passed
🌀 Generated Regression Tests	✅ 239 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_config.py::test_console_output_accumulate_error	132μs	111μs	18.5%✅
test_config.py::test_console_output_disable_error	17.2μs	16.1μs	6.88%✅
test_config.py::test_console_output_replace_error	147μs	109μs	34.9%✅

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import sys
import traceback
import types

# imports
import pytest
from panel.viewable import MimeRenderMixin


# Minimal stubs to replace panel.config, panel.io.state, and panel.util.escape
class DummyConfig:
    def __init__(self):
        self.console_output = None

config = DummyConfig()

class DummyHandle:
    def __init__(self):
        self.updated = []
    def update(self, data, raw=False):
        self.updated.append((data, raw))

class DummyState:
    def __init__(self):
        self._handles = {}

state = DummyState()

def escape(s):
    # Simulate HTML escaping: replace < and > with &lt; and &gt;
    return s.replace('<', '&lt;').replace('>', '&gt;')
from panel.viewable import MimeRenderMixin

# unit tests

class TestOnError:
    # Helper to set up state._handles for each test
    def setup_method(self):
        state._handles.clear()
        config.console_output = None

    # --- Basic Test Cases ---

    def test_no_handle_ref_not_in_handles(self):
        """Should do nothing if ref not in state._handles"""
        m = MimeRenderMixin()
        config.console_output = 'accumulate'
        # state._handles is empty
        m._on_error('missing_ref', ValueError("fail")) # 756ns -> 859ns (12.0% slower)

    def test_no_handle_console_output_none(self):
        """Should do nothing if console_output is None"""
        m = MimeRenderMixin()
        dummy_handle = DummyHandle()
        state._handles['foo'] = (dummy_handle, [])
        config.console_output = None
        m._on_error('foo', ValueError("fail")) # 762ns -> 821ns (7.19% slower)

    def test_no_handle_console_output_disable(self):
        """Should do nothing if console_output is 'disable'"""
        m = MimeRenderMixin()
        dummy_handle = DummyHandle()
        state._handles['foo'] = (dummy_handle, [])
        config.console_output = 'disable'
        m._on_error('foo', ValueError("fail")) # 732ns -> 743ns (1.48% slower)

    def test_accumulate_adds_formatted_traceback(self):
        """Should append formatted, escaped traceback to accumulator and update handle"""
        m = MimeRenderMixin()
        dummy_handle = DummyHandle()
        accumulator = []
        state._handles['foo'] = (dummy_handle, accumulator)
        config.console_output = 'accumulate'
        try:
            raise ValueError("fail!")
        except Exception as e:
            m._on_error('foo', e)
        data, raw = dummy_handle.updated[-1]

    def test_replace_replaces_accumulator(self):
        """Should replace accumulator with formatted, escaped traceback and update handle"""
        m = MimeRenderMixin()
        dummy_handle = DummyHandle()
        accumulator = ["old error", "older error"]
        state._handles['foo'] = (dummy_handle, accumulator)
        config.console_output = 'replace'
        try:
            raise RuntimeError("fail2")
        except Exception as e:
            m._on_error('foo', e)
        data, raw = dummy_handle.updated[-1]

    # --- Edge Test Cases ---

    def test_accumulate_multiple_errors(self):
        """Should accumulate multiple errors and update handle with all"""
        m = MimeRenderMixin()
        dummy_handle = DummyHandle()
        accumulator = []
        state._handles['foo'] = (dummy_handle, accumulator)
        config.console_output = 'accumulate'
        for i in range(3):
            try:
                raise ValueError(f"fail-{i}")
            except Exception as e:
                m._on_error('foo', e)
        for i, entry in enumerate(accumulator):
            pass
        # The last update should include all three entries
        data, raw = dummy_handle.updated[-1]
        for entry in accumulator:
            pass

    def test_replace_multiple_errors(self):
        """Should only keep the most recent error in accumulator in 'replace' mode"""
        m = MimeRenderMixin()
        dummy_handle = DummyHandle()
        accumulator = []
        state._handles['foo'] = (dummy_handle, accumulator)
        config.console_output = 'replace'
        for i in range(3):
            try:
                raise ValueError(f"fail-{i}")
            except Exception as e:
                m._on_error('foo', e)

    def test_accumulator_initially_nonempty(self):
        """If accumulator is not empty, should append or replace as appropriate"""
        m = MimeRenderMixin()
        dummy_handle = DummyHandle()
        accumulator = ["preexisting"]
        state._handles['foo'] = (dummy_handle, accumulator)
        config.console_output = 'accumulate'
        try:
            raise KeyError("missing")
        except Exception as e:
            m._on_error('foo', e)

        # Now test replace mode
        accumulator = ["preexisting"]
        state._handles['bar'] = (dummy_handle, accumulator)
        config.console_output = 'replace'
        try:
            raise KeyError("missing2")
        except Exception as e:
            m._on_error('bar', e)

    def test_accumulator_empty_no_update(self):
        """If accumulator is empty after operation, handle.update should not be called"""
        m = MimeRenderMixin()
        dummy_handle = DummyHandle()
        accumulator = []
        state._handles['foo'] = (dummy_handle, accumulator)
        config.console_output = 'replace'
        # Manually clear accumulator after call to simulate
        try:
            raise ValueError("fail")
        except Exception as e:
            m._on_error('foo', e)
            accumulator.clear()  # simulate external clearing
            # Call again, now accumulator is empty
            m._on_error('foo', e)
        # After clearing, update should not be called again with empty accumulator

    def test_escape_html_in_traceback(self):
        """Should escape HTML special chars in traceback"""
        m = MimeRenderMixin()
        dummy_handle = DummyHandle()
        accumulator = []
        state._handles['foo'] = (dummy_handle, accumulator)
        config.console_output = 'accumulate'
        # Raise an exception with < and > in the message
        try:
            raise ValueError("<tag> error >")
        except Exception as e:
            m._on_error('foo', e)

    # --- Large Scale Test Cases ---

    def test_accumulate_large_number_of_errors(self):
        """Should handle accumulation of many errors efficiently"""
        m = MimeRenderMixin()
        dummy_handle = DummyHandle()
        accumulator = []
        state._handles['foo'] = (dummy_handle, accumulator)
        config.console_output = 'accumulate'
        for i in range(100):  # large but within 1000 elements
            try:
                raise RuntimeError(f"fail-{i}")
            except Exception as e:
                m._on_error('foo', e)
        # Only the last update should contain all 100 entries
        data, raw = dummy_handle.updated[-1]
        for i in range(100):
            pass

    def test_replace_large_number_of_errors(self):
        """Should only keep the most recent error in large replace scenario"""
        m = MimeRenderMixin()
        dummy_handle = DummyHandle()
        accumulator = []
        state._handles['foo'] = (dummy_handle, accumulator)
        config.console_output = 'replace'
        for i in range(100):
            try:
                raise RuntimeError(f"fail-{i}")
            except Exception as e:
                m._on_error('foo', e)

    def test_multiple_handles_large_scale(self):
        """Should handle multiple refs/handles independently in large scale"""
        m = MimeRenderMixin()
        handles = [DummyHandle() for _ in range(10)]
        accumulators = [[] for _ in range(10)]
        for i in range(10):
            state._handles[f'ref{i}'] = (handles[i], accumulators[i])
        config.console_output = 'accumulate'
        for i in range(10):
            try:
                raise ValueError(f"error-{i}")
            except Exception as e:
                m._on_error(f'ref{i}', e)
        for i in range(10):
            data, raw = handles[i].updated[-1]
# 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-MimeRenderMixin._on_error-mh9zh8af and push.