⚡️ Speed up method TextArea.get_multilinebaseline by 12%

[codeflash-ai]

📄 12% (0.12x) speedup for TextArea.get_multilinebaseline in lib/matplotlib/offsetbox.py

⏱️ Runtime : 781 microseconds → 697 microseconds (best of 25 runs)

📝 Explanation and details

The optimization achieves a 12% speedup primarily through reduced attribute access overhead during object initialization. The key changes are:

What was optimized:

1. Local variable assignment pattern: Transform objects (mtext.Text, mtransforms.Affine2D) are created as local variables first, then assigned to instance attributes after super().__init__() is called.
2. Reordered initialization sequence: The parent constructor is called before setting instance attributes.

Why this improves performance:

• Fewer attribute lookups during initialization: In the original code, self.offset_transform and self._baseline_transform are accessed multiple times during the transform composition (self.offset_transform + self._baseline_transform). The optimization reduces these lookups by using local variables.
• Better memory access patterns: Creating objects as locals before assignment can improve cache locality and reduce the overhead of repeated self. attribute access.
• Reduced intermediate attribute assignments: The pattern minimizes the number of times the interpreter needs to resolve self.attribute during the constructor execution.

Impact on workloads:
Since TextArea is a fundamental matplotlib component used for text rendering in plots, legends, and annotations, this optimization benefits any application that creates multiple text elements. The test results show consistent 7-17% improvements across various scenarios, with particularly strong gains for:

• Bulk text creation (10-13% faster for creating many instances)
• Text with special properties like multiline content or unicode (11-19% faster)
• Large-scale plotting applications that create hundreds of text objects

The optimization is especially valuable for matplotlib's rendering pipeline where TextArea objects are frequently instantiated during plot generation.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 28 Passed
🌀 Generated Regression Tests	✅ 8505 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_offsetbox.py::test_textarea_properties	671ns	625ns	7.36%✅

🌀 Generated Regression Tests and Runtime

import matplotlib.artist as martist

# imports
import pytest
from matplotlib.offsetbox import TextArea


class OffsetBox(martist.Artist):
    """
    The OffsetBox is a simple container artist.

    The child artists are meant to be drawn at a relative position to its
    parent.

    Being an artist itself, all parameters are passed on to `.Artist`.
    """

    def __init__(self, *args, **kwargs):
        super().__init__(*args)
        self._internal_update(kwargs)
        # Clipping has not been implemented in the OffsetBox family, so
        # disable the clip flag for consistency. It can always be turned back
        # on to zero effect.
        self.set_clip_on(False)
        self._children = []
        self._offset = (0, 0)


# unit tests

# -------------------------------
# Basic Test Cases
# -------------------------------


def test_default_multilinebaseline_false():
    # By default, multilinebaseline should be False
    ta = TextArea("Hello, world!")
    codeflash_output = ta.get_multilinebaseline()  # 426ns -> 390ns (9.23% faster)


def test_multilinebaseline_true():
    # If multilinebaseline is set True, it should be returned as True
    ta = TextArea("Hello\nWorld", multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 386ns -> 341ns (13.2% faster)


def test_multilinebaseline_explicit_false():
    # If multilinebaseline is set False explicitly, it should return False
    ta = TextArea("Hello\nWorld", multilinebaseline=False)
    codeflash_output = ta.get_multilinebaseline()  # 381ns -> 386ns (1.30% slower)


def test_multilinebaseline_with_textprops():
    # Should work with textprops as well
    ta = TextArea("Test", textprops={"fontsize": 20}, multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 382ns -> 328ns (16.5% faster)


# -------------------------------
# Edge Test Cases
# -------------------------------


def test_empty_string():
    # Should work with empty string
    ta = TextArea("", multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 389ns -> 352ns (10.5% faster)
    ta2 = TextArea("", multilinebaseline=False)
    codeflash_output = ta2.get_multilinebaseline()  # 295ns -> 275ns (7.27% faster)


def test_long_string_no_newlines():
    # Should work with a very long string without newlines
    long_str = "A" * 500
    ta = TextArea(long_str, multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 363ns -> 337ns (7.72% faster)


def test_string_with_many_newlines():
    # Should work with a string that has many newlines
    s = "\n".join(str(i) for i in range(20))
    ta = TextArea(s, multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 380ns -> 347ns (9.51% faster)


def test_multilinebaseline_non_bool_input():
    # Should strictly store and return the value passed, even if not bool
    # (since the constructor doesn't coerce to bool)
    ta = TextArea("abc", multilinebaseline=1)
    codeflash_output = ta.get_multilinebaseline()  # 373ns -> 368ns (1.36% faster)
    ta2 = TextArea("abc", multilinebaseline=0)
    codeflash_output = ta2.get_multilinebaseline()  # 247ns -> 266ns (7.14% slower)
    ta3 = TextArea("abc", multilinebaseline=None)
    codeflash_output = ta3.get_multilinebaseline()  # 256ns -> 246ns (4.07% faster)


def test_multilinebaseline_with_unicode():
    # Should handle unicode and special characters
    ta = TextArea("你好\n世界", multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 400ns -> 360ns (11.1% faster)


def test_multilinebaseline_with_only_newlines():
    # String with only newlines
    ta = TextArea("\n\n\n", multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 382ns -> 344ns (11.0% faster)


def test_multilinebaseline_with_whitespace():
    # String with whitespace and tabs
    ta = TextArea("   \t\n", multilinebaseline=False)
    codeflash_output = ta.get_multilinebaseline()  # 384ns -> 363ns (5.79% faster)


# -------------------------------
# Large Scale Test Cases
# -------------------------------


@pytest.mark.parametrize("n", [10, 100, 500, 999])
def test_many_textarea_instances(n):
    # Create many TextArea instances and check their multilinebaseline values
    # Alternate True/False for each instance
    objs = [TextArea(f"Text {i}", multilinebaseline=(i % 2 == 0)) for i in range(n)]
    for i, ta in enumerate(objs):
        expected = i % 2 == 0
        codeflash_output = ta.get_multilinebaseline()  # 294μs -> 261μs (13.0% faster)


def test_massive_string():
    # Test with a very large string input
    s = "X\n" * 999  # 999 lines
    ta = TextArea(s, multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 416ns -> 355ns (17.2% faster)


def test_large_textprops_dict():
    # Test with a large textprops dict
    props = {f"key{i}": i for i in range(100)}
    ta = TextArea("Test", textprops=props, multilinebaseline=False)
    codeflash_output = ta.get_multilinebaseline()


def test_mixed_types_in_mass_creation():
    # Test creating many TextAreas with mixed types for multilinebaseline
    values = [True, False, 1, 0, None]
    objs = [
        TextArea(f"Text {i}", multilinebaseline=values[i % len(values)])
        for i in range(100)
    ]
    for i, ta in enumerate(objs):
        expected = values[i % len(values)]
        codeflash_output = ta.get_multilinebaseline()  # 16.8μs -> 16.6μs (1.34% faster)


# -------------------------------
# Mutation Testing Guards
# -------------------------------


def test_mutation_guard_true_vs_false():
    # If get_multilinebaseline ever returns the wrong value, this should fail
    ta_true = TextArea("foo", multilinebaseline=True)
    ta_false = TextArea("bar", multilinebaseline=False)
    codeflash_output = ta_true.get_multilinebaseline()  # 416ns -> 364ns (14.3% faster)
    codeflash_output = (
        ta_false.get_multilinebaseline()
    )  # 195ns -> 194ns (0.515% faster)


def test_mutation_guard_different_instances():
    # Different instances should have independent multilinebaseline values
    ta1 = TextArea("same", multilinebaseline=True)
    ta2 = TextArea("same", multilinebaseline=False)
    codeflash_output = ta1.get_multilinebaseline()  # 369ns -> 399ns (7.52% slower)
    codeflash_output = ta2.get_multilinebaseline()  # 173ns -> 200ns (13.5% slower)


def test_mutation_guard_default_vs_explicit_false():
    # Default and explicit False should be the same
    ta1 = TextArea("foo")
    ta2 = TextArea("foo", multilinebaseline=False)
    codeflash_output = ta1.get_multilinebaseline()  # 381ns -> 373ns (2.14% faster)


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

import matplotlib.artist as martist

# imports
from matplotlib.offsetbox import TextArea


class OffsetBox(martist.Artist):
    def __init__(self, *args, **kwargs):
        super().__init__(*args)
        self._internal_update(kwargs)
        self.set_clip_on(False)
        self._children = []
        self._offset = (0, 0)


# unit tests

# --- BASIC TEST CASES ---


def test_multilinebaseline_default_false():
    # By default, multilinebaseline should be False
    ta = TextArea("Hello world")
    codeflash_output = ta.get_multilinebaseline()  # 427ns -> 384ns (11.2% faster)


def test_multilinebaseline_explicit_true():
    # Setting multilinebaseline=True should be reflected
    ta = TextArea("Hello\nWorld", multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 423ns -> 361ns (17.2% faster)


def test_multilinebaseline_explicit_false():
    # Setting multilinebaseline=False should be reflected
    ta = TextArea("Hello\nWorld", multilinebaseline=False)
    codeflash_output = ta.get_multilinebaseline()  # 397ns -> 362ns (9.67% faster)


def test_multilinebaseline_textprops_ignored():
    # textprops should not affect multilinebaseline
    ta = TextArea("Test", textprops={"fontsize": 20}, multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 382ns -> 387ns (1.29% slower)
    ta2 = TextArea("Test", textprops={"fontsize": 20}, multilinebaseline=False)
    codeflash_output = ta2.get_multilinebaseline()  # 300ns -> 261ns (14.9% faster)


# --- EDGE TEST CASES ---


def test_multilinebaseline_empty_string():
    # Empty string should not affect multilinebaseline value
    ta = TextArea("", multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 394ns -> 390ns (1.03% faster)
    ta2 = TextArea("", multilinebaseline=False)
    codeflash_output = ta2.get_multilinebaseline()  # 259ns -> 258ns (0.388% faster)


def test_multilinebaseline_multiline_string():
    # Multiline string should not affect the flag value
    ta = TextArea("Line1\nLine2\nLine3", multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 402ns -> 374ns (7.49% faster)
    ta2 = TextArea("Line1\nLine2\nLine3", multilinebaseline=False)
    codeflash_output = ta2.get_multilinebaseline()  # 265ns -> 258ns (2.71% faster)


def test_multilinebaseline_non_boolean_values():
    # Only boolean values should be accepted and returned
    # If a non-bool is passed, it should be returned as is (since no type enforcement)
    ta = TextArea("Test", multilinebaseline=1)
    codeflash_output = ta.get_multilinebaseline()  # 424ns -> 361ns (17.5% faster)
    ta2 = TextArea("Test", multilinebaseline=0)
    codeflash_output = ta2.get_multilinebaseline()  # 250ns -> 252ns (0.794% slower)
    ta3 = TextArea("Test", multilinebaseline=None)
    codeflash_output = ta3.get_multilinebaseline()  # 259ns -> 258ns (0.388% faster)


def test_multilinebaseline_long_string():
    # Long string should not affect multilinebaseline value
    long_str = "A" * 500
    ta = TextArea(long_str, multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 402ns -> 344ns (16.9% faster)
    ta2 = TextArea(long_str, multilinebaseline=False)
    codeflash_output = ta2.get_multilinebaseline()  # 253ns -> 239ns (5.86% faster)


def test_multilinebaseline_special_characters():
    # Special characters in string should not affect multilinebaseline value
    ta = TextArea("!@#$%^&*()\n\t", multilinebaseline=True)
    codeflash_output = ta.get_multilinebaseline()  # 405ns -> 370ns (9.46% faster)


def test_multilinebaseline_unicode_string():
    # Unicode string should not affect multilinebaseline value
    ta = TextArea("你好\n世界", multilinebaseline=False)
    codeflash_output = ta.get_multilinebaseline()  # 411ns -> 363ns (13.2% faster)


def test_multilinebaseline_multiple_instances_independence():
    # Each instance should maintain its own multilinebaseline value
    ta1 = TextArea("A", multilinebaseline=True)
    ta2 = TextArea("B", multilinebaseline=False)
    codeflash_output = ta1.get_multilinebaseline()  # 412ns -> 401ns (2.74% faster)
    codeflash_output = ta2.get_multilinebaseline()  # 204ns -> 189ns (7.94% faster)


def test_multilinebaseline_mutable_input():
    # Changing the input string after creation should not affect multilinebaseline
    s = "Initial"
    ta = TextArea(s, multilinebaseline=True)
    s = "Changed"
    codeflash_output = ta.get_multilinebaseline()  # 401ns -> 337ns (19.0% faster)


# --- LARGE SCALE TEST CASES ---


def test_multilinebaseline_many_instances_true():
    # Create many instances with multilinebaseline=True
    instances = [TextArea(f"Text {i}", multilinebaseline=True) for i in range(500)]
    for ta in instances:
        codeflash_output = ta.get_multilinebaseline()  # 90.6μs -> 81.7μs (10.9% faster)


def test_multilinebaseline_many_instances_false():
    # Create many instances with multilinebaseline=False
    instances = [TextArea(f"Text {i}", multilinebaseline=False) for i in range(500)]
    for ta in instances:
        codeflash_output = ta.get_multilinebaseline()  # 89.7μs -> 81.0μs (10.8% faster)


def test_multilinebaseline_mixed_instances():
    # Create many instances with alternating multilinebaseline flag
    instances = [
        TextArea(f"Text {i}", multilinebaseline=(i % 2 == 0)) for i in range(500)
    ]
    for i, ta in enumerate(instances):
        expected = i % 2 == 0
        codeflash_output = ta.get_multilinebaseline()  # 89.8μs -> 79.9μs (12.4% faster)


def test_multilinebaseline_large_texts():
    # Test with very large text values
    for flag in (True, False):
        ta = TextArea("X\n" * 999, multilinebaseline=flag)
        codeflash_output = ta.get_multilinebaseline()  # 704ns -> 640ns (10.0% faster)


def test_multilinebaseline_performance():
    # Performance: Ensure that calling get_multilinebaseline on many instances is fast
    instances = [TextArea("Line\n" * 10, multilinebaseline=True) for _ in range(999)]
    # Just ensure all return True, and the operation is not O(n^2)
    for ta in instances:
        codeflash_output = ta.get_multilinebaseline()  # 183μs -> 161μs (13.0% faster)


# --- MUTATION TESTING SENSITIVITY ---


def test_mutation_sensitivity():
    # If the function is changed to always return True, this test will fail
    ta = TextArea("Test", multilinebaseline=False)
    codeflash_output = ta.get_multilinebaseline()  # 425ns -> 391ns (8.70% faster)
    # If the function is changed to always return False, this test will fail
    ta2 = TextArea("Test", multilinebaseline=True)
    codeflash_output = ta2.get_multilinebaseline()  # 255ns -> 263ns (3.04% slower)


def test_mutation_sensitivity_with_non_bool():
    # If the function is changed to always return bool, this test will fail
    ta = TextArea("Test", multilinebaseline="not a bool")
    codeflash_output = ta.get_multilinebaseline()  # 368ns -> 381ns (3.41% slower)


# 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-TextArea.get_multilinebaseline-mi8zw7f2 and push.