⚡️ Speed up function Error by 37%

[codeflash-ai]

📄 37% (0.37x) speedup for Error in lib/matplotlib/_mathtext.py

⏱️ Runtime : 1.02 milliseconds → 745 microseconds (best of 132 runs)

📝 Explanation and details

The optimization caches the Empty().setParseAction(raise_error) parser element to avoid recreating it on every function call, achieving a 36% speedup from 1.02ms to 745μs.

Key optimization:

• Caches parsed element creation: Instead of calling Empty().setParseAction(raise_error) for every Error() call (which was taking 97.3% of execution time), the optimization creates this parser element once and stores it as a function attribute.
• Uses copy() for safety: Returns e.copy() to ensure each caller gets a fresh parser element without mutation side effects, preserving the original behavior completely.

Why this works:

• The line profiler shows Empty().setParseAction(raise_error) was the bottleneck, taking 2.79ms out of 2.87ms total time in the original version
• In the optimized version, this expensive operation only happens once (46.2μs on first call), while subsequent calls just retrieve the cached element (284-317ns) and copy it (13.4μs average)
• Empty() object creation and setParseAction() method calls have significant overhead when repeated

Impact on workloads:
Based on the function references, Error() is called from cmd() helper functions that define TeX commands in matplotlib's math text parser. The cmd() function creates error handlers for malformed TeX expressions like \frac, \sqrt, \left/\right delimiters, etc. Since mathematical text parsing can involve many such commands, this optimization directly benefits:

• Mathematical expression rendering performance
• TeX command parsing in matplotlib plots
• Error handling paths in complex mathematical notation

Test results show consistent 20-30% improvements across all test cases, with the largest gain (53%) in the stress test creating 100 different error parsers, demonstrating the optimization scales well with frequent Error() instantiation.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from matplotlib._mathtext import Error
from pyparsing import ParseFatalException

# unit tests

# 1. Basic Test Cases


def test_error_raises_with_basic_message():
    """Test that Error raises ParseFatalException with the correct message on basic input."""
    codeflash_output = Error("basic error")
    parser = codeflash_output  # 17.2μs -> 14.0μs (22.8% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("anything")


def test_error_with_empty_string_message():
    """Test that Error raises with an empty string message."""
    codeflash_output = Error("")
    parser = codeflash_output  # 17.1μs -> 13.7μs (24.3% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("data")


def test_error_with_special_characters_in_message():
    """Test that Error raises with a message containing special characters."""
    special_msg = "err!@#\n\t"
    codeflash_output = Error(special_msg)
    parser = codeflash_output  # 16.6μs -> 13.3μs (25.0% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_with_unicode_message():
    """Test that Error raises with a unicode message."""
    unicode_msg = "Ошибка 🚫"
    codeflash_output = Error(unicode_msg)
    parser = codeflash_output  # 16.6μs -> 13.6μs (22.3% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("тест")


# 2. Edge Test Cases


def test_error_with_empty_input_string():
    """Test Error with an empty input string."""
    codeflash_output = Error("Empty input error")
    parser = codeflash_output  # 16.8μs -> 13.6μs (23.7% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("")


def test_error_with_long_message():
    """Test Error with a very long message string."""
    long_msg = "X" * 1000
    codeflash_output = Error(long_msg)
    parser = codeflash_output  # 17.1μs -> 13.9μs (23.2% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("longinput")


def test_error_with_non_ascii_input_string():
    """Test Error with non-ASCII input string."""
    codeflash_output = Error("Non-ASCII input error")
    parser = codeflash_output  # 16.8μs -> 13.7μs (22.7% faster)
    input_str = "测试数据"
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString(input_str)


def test_error_with_whitespace_input_string():
    """Test Error with input string containing only whitespace."""
    codeflash_output = Error("Whitespace error")
    parser = codeflash_output  # 16.6μs -> 13.7μs (21.9% faster)
    input_str = " \t\n "
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString(input_str)


def test_error_with_location_parameter():
    """Test that the location parameter in the exception is always 0 (since Empty always matches at start)."""
    codeflash_output = Error("Location test")
    parser = codeflash_output  # 16.5μs -> 13.4μs (23.2% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("abcdef")


def test_error_with_multiple_calls():
    """Test that multiple calls to the same Error parser each raise the correct error."""
    codeflash_output = Error("Repeated error")
    parser = codeflash_output  # 16.7μs -> 13.5μs (24.2% faster)
    for i in range(3):
        with pytest.raises(ParseFatalException) as excinfo:
            parser.parseString(f"input{i}")


# 3. Large Scale Test Cases


def test_error_with_large_input_string():
    """Test Error with a very large input string."""
    codeflash_output = Error("Large input error")
    parser = codeflash_output  # 16.3μs -> 13.5μs (20.3% faster)
    large_input = "A" * 1000
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString(large_input)


def test_error_with_many_different_messages():
    """Test Error with many different messages to ensure no cross-contamination."""
    for i in range(100):
        msg = f"Error {i}"
        codeflash_output = Error(msg)
        parser = codeflash_output  # 482μs -> 315μs (53.0% faster)
        with pytest.raises(ParseFatalException) as excinfo:
            parser.parseString(f"input_{i}")


def test_error_parser_type_and_repr():
    """Test that the returned object is a ParserElement and its repr contains the message."""
    msg = "repr test"
    codeflash_output = Error(msg)
    parser = codeflash_output  # 16.8μs -> 13.4μs (25.4% faster)


def test_error_parser_does_not_consume_input():
    """Test that Error parser does not consume any input (Empty)."""
    codeflash_output = Error("Does not consume")
    parser = codeflash_output  # 16.8μs -> 13.6μs (23.3% faster)
    with pytest.raises(ParseFatalException):
        result = parser.parseString("abcde", parseAll=False)
    # The input should remain unchanged after failure


def test_error_with_various_input_types():
    """Test Error with various types of input strings, including numbers and symbols."""
    codeflash_output = Error("Various input types")
    parser = codeflash_output  # 16.5μs -> 13.6μs (21.6% faster)
    inputs = ["123456", "!@#$%^&*()", "mixed123!@#", "long" * 250]
    for inp in inputs:
        with pytest.raises(ParseFatalException) as excinfo:
            parser.parseString(inp)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from matplotlib._mathtext import Error
from pyparsing import ParseFatalException

# unit tests

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


def test_error_raises_with_simple_message():
    # Test that Error raises the correct exception with a simple message
    codeflash_output = Error("Test error")
    parser = codeflash_output  # 16.8μs -> 13.5μs (24.7% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("anything")


def test_error_raises_with_empty_message():
    # Test that Error raises with an empty message
    codeflash_output = Error("")
    parser = codeflash_output  # 16.8μs -> 13.3μs (26.0% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_raises_with_special_characters_in_message():
    # Test that Error raises with a message containing special characters
    special_msg = "Error: something went wrong! @#%$"
    codeflash_output = Error(special_msg)
    parser = codeflash_output  # 16.7μs -> 13.4μs (24.7% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_raises_with_unicode_message():
    # Test that Error raises with a unicode message
    unicode_msg = "Ошибка: неверный ввод 🚫"
    codeflash_output = Error(unicode_msg)
    parser = codeflash_output  # 16.7μs -> 13.2μs (26.9% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


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


def test_error_raises_with_long_message():
    # Test with a very long error message
    long_msg = "X" * 1000
    codeflash_output = Error(long_msg)
    parser = codeflash_output  # 16.3μs -> 13.3μs (22.0% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_raises_with_empty_input():
    # Test that Error raises even when input is empty
    codeflash_output = Error("Empty input error")
    parser = codeflash_output  # 16.8μs -> 13.2μs (27.2% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("")


def test_error_raises_with_whitespace_input():
    # Test with input that is only whitespace
    codeflash_output = Error("Whitespace error")
    parser = codeflash_output  # 16.9μs -> 13.0μs (30.3% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("   \t\n ")


def test_error_raises_with_non_string_message():
    # Test with a non-string message (should convert to string or raise)
    codeflash_output = Error(12345)
    parser = codeflash_output  # 16.8μs -> 13.5μs (24.8% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_raises_with_none_message():
    # Test with None as message (should convert to string 'None')
    codeflash_output = Error(None)
    parser = codeflash_output  # 17.0μs -> 13.4μs (26.7% faster)
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString("input")


def test_error_raises_with_loc_argument():
    # Test that location argument is correctly passed to exception
    codeflash_output = Error("Location test")
    parser = codeflash_output  # 16.5μs -> 13.2μs (25.6% faster)
    input_str = "abc"
    try:
        parser.parseString(input_str)
    except ParseFatalException as e:
        pass
    else:
        pass


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


def test_error_raises_with_large_input():
    # Test that Error raises with a large input string
    codeflash_output = Error("Large input error")
    parser = codeflash_output  # 16.5μs -> 13.2μs (25.0% faster)
    large_input = "a" * 1000
    with pytest.raises(ParseFatalException) as excinfo:
        parser.parseString(large_input)


def test_error_raises_multiple_times_in_loop():
    # Test that Error can be used repeatedly without side effects
    codeflash_output = Error("Repeated error")
    parser = codeflash_output  # 16.5μs -> 12.7μs (29.9% faster)
    for i in range(10):  # keep below 1000 for performance
        with pytest.raises(ParseFatalException) as excinfo:
            parser.parseString(str(i))


def test_error_parser_element_type():
    # Test that Error returns a ParserElement instance
    codeflash_output = Error("Type test")
    parser = codeflash_output  # 16.6μs -> 13.4μs (24.3% faster)


def test_error_does_not_consume_input():
    # Error should not consume any input, since it uses Empty()
    codeflash_output = Error("No consume")
    parser = codeflash_output  # 17.8μs -> 14.3μs (24.6% faster)
    with pytest.raises(ParseFatalException):
        parser.parseString("someinput")
    # If we use Empty() alone, it would succeed and not consume input


def test_error_always_raises():
    # Error should always raise, regardless of input
    codeflash_output = Error("Always error")
    parser = codeflash_output  # 16.8μs -> 13.3μs (25.7% faster)
    for test_input in ["", "abc", "123", "!", "long" * 100]:
        with pytest.raises(ParseFatalException) as excinfo:
            parser.parseString(test_input)


def test_error_with_parse_action_signature():
    # Ensure parse action signature matches pyparsing requirements
    codeflash_output = Error("Signature test")
    parser = codeflash_output  # 16.9μs -> 13.3μs (26.5% faster)
    # Should accept (str, int, ParseResults)
    with pytest.raises(ParseFatalException):
        parser.parseString("signature")


# -------------------- NEGATIVE TESTS --------------------


def test_error_does_not_raise_other_exceptions():
    # Ensure Error only raises ParseFatalException, not other exceptions
    codeflash_output = Error("Fatal only")
    parser = codeflash_output  # 16.8μs -> 13.2μs (27.1% faster)
    try:
        parser.parseString("input")
    except Exception as e:
        pass


def test_error_message_mutation():
    # Mutation: If Error does NOT raise, this test should fail
    codeflash_output = Error("Mutation test")
    parser = codeflash_output  # 16.6μs -> 13.1μs (26.5% faster)
    try:
        result = parser.parseString("input")
    except ParseFatalException as e:
        pass


# 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-Error-mjd1d5mx and push.