⚡️ Speed up method FontManager.score_style by 12%

[codeflash-ai]

📄 12% (0.12x) speedup for FontManager.score_style in lib/matplotlib/font_manager.py

⏱️ Runtime : 1.16 milliseconds → 1.04 milliseconds (best of 5 runs)

📝 Explanation and details

The optimization improves the FontManager.__init__ method by eliminating duplicate font path processing. The key change replaces nested loops that iterate over font extensions and paths separately with a single collection phase followed by one iteration.

What was optimized:

• Duplicate elimination: The original code used nested loops that could process the same font file multiple times if it appeared in both findSystemFonts(paths, fontext=fontext) and findSystemFonts(fontext=fontext). The optimized version uses a set() to automatically deduplicate paths before processing.
• Reduced iterations: Instead of calling self.addfont(path) potentially multiple times for the same file, each unique font path is now processed exactly once.

Why this leads to speedup:

• Fewer I/O operations: Each self.addfont(path) call involves file system operations (opening font files, reading metadata). Eliminating duplicates reduces these expensive operations.
• Reduced exception handling overhead: The try/except blocks around self.addfont() are executed fewer times when duplicates are removed.
• Memory efficiency: Less temporary object creation and garbage collection pressure from processing the same files repeatedly.

Performance characteristics:
The 11% speedup is most beneficial when there's significant overlap between system font directories and bundled font paths. Systems with many duplicate font references (common in cross-platform font management) will see the greatest improvement.

The annotated test results show the optimization performs consistently well across different test scenarios, with most cases showing modest improvements and no significant regressions. The optimization is particularly effective for workloads that trigger font cache building, which is a one-time but potentially expensive operation during matplotlib initialization.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from matplotlib.font_manager import FontManager

# unit tests


@pytest.fixture
def fm():
    """Fixture to provide a FontManager instance."""
    return FontManager()


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


def test_exact_match_regular(fm):
    # Test exact match for 'normal'
    codeflash_output = fm.score_style(
        "normal", "normal"
    )  # 766ns -> 749ns (2.27% faster)


def test_exact_match_italic(fm):
    # Test exact match for 'italic'
    codeflash_output = fm.score_style(
        "italic", "italic"
    )  # 707ns -> 786ns (10.1% slower)


def test_exact_match_oblique(fm):
    # Test exact match for 'oblique'
    codeflash_output = fm.score_style(
        "oblique", "oblique"
    )  # 723ns -> 738ns (2.03% slower)


def test_italic_oblique_match(fm):
    # Test match between 'italic' and 'oblique'
    codeflash_output = fm.score_style(
        "italic", "oblique"
    )  # 968ns -> 885ns (9.38% faster)
    codeflash_output = fm.score_style(
        "oblique", "italic"
    )  # 336ns -> 375ns (10.4% slower)


def test_no_match_normal_italic(fm):
    # Test no match between 'normal' and 'italic'
    codeflash_output = fm.score_style(
        "normal", "italic"
    )  # 1.00μs -> 769ns (30.3% faster)
    codeflash_output = fm.score_style(
        "italic", "normal"
    )  # 362ns -> 325ns (11.4% faster)


def test_no_match_normal_oblique(fm):
    # Test no match between 'normal' and 'oblique'
    codeflash_output = fm.score_style(
        "normal", "oblique"
    )  # 950ns -> 791ns (20.1% faster)
    codeflash_output = fm.score_style(
        "oblique", "normal"
    )  # 382ns -> 364ns (4.95% faster)


def test_no_match_other_styles(fm):
    # Test no match between unrelated styles
    codeflash_output = fm.score_style("bold", "italic")  # 934ns -> 756ns (23.5% faster)
    codeflash_output = fm.score_style(
        "bold", "oblique"
    )  # 266ns -> 225ns (18.2% faster)
    codeflash_output = fm.score_style("bold", "normal")  # 263ns -> 209ns (25.8% faster)
    codeflash_output = fm.score_style("italic", "bold")  # 304ns -> 269ns (13.0% faster)
    codeflash_output = fm.score_style(
        "oblique", "bold"
    )  # 293ns -> 231ns (26.8% faster)


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


def test_case_sensitivity(fm):
    # Test that style matching is case-sensitive
    codeflash_output = fm.score_style(
        "Italic", "italic"
    )  # 836ns -> 953ns (12.3% slower)
    codeflash_output = fm.score_style(
        "Oblique", "oblique"
    )  # 348ns -> 360ns (3.33% slower)
    codeflash_output = fm.score_style(
        "NORMAL", "normal"
    )  # 248ns -> 330ns (24.8% slower)


def test_empty_strings(fm):
    # Test empty string as style
    codeflash_output = fm.score_style("", "")  # 753ns -> 740ns (1.76% faster)
    codeflash_output = fm.score_style("", "italic")  # 387ns -> 398ns (2.76% slower)
    codeflash_output = fm.score_style("italic", "")  # 312ns -> 296ns (5.41% faster)


def test_none_values(fm):
    # Test None as style
    codeflash_output = fm.score_style(None, None)  # 809ns -> 741ns (9.18% faster)
    codeflash_output = fm.score_style(None, "italic")  # 579ns -> 621ns (6.76% slower)
    codeflash_output = fm.score_style("italic", None)  # 358ns -> 357ns (0.280% faster)


def test_numeric_styles(fm):
    # Test numeric values as style
    codeflash_output = fm.score_style(1, 1)  # 809ns -> 752ns (7.58% faster)
    codeflash_output = fm.score_style(0, 1)  # 565ns -> 642ns (12.0% slower)
    codeflash_output = fm.score_style("italic", 1)  # 405ns -> 401ns (0.998% faster)
    codeflash_output = fm.score_style(1, "italic")  # 285ns -> 304ns (6.25% slower)


def test_unusual_strings(fm):
    # Test unusual strings
    codeflash_output = fm.score_style("foo", "foo")  # 804ns -> 756ns (6.35% faster)
    codeflash_output = fm.score_style("foo", "bar")  # 453ns -> 437ns (3.66% faster)
    codeflash_output = fm.score_style("italic", "foo")  # 322ns -> 330ns (2.42% slower)
    codeflash_output = fm.score_style("oblique", "bar")  # 264ns -> 256ns (3.12% faster)


def test_tuple_input(fm):
    # Test tuple input
    codeflash_output = fm.score_style(
        ("italic",), ("italic",)
    )  # 702ns -> 874ns (19.7% slower)
    codeflash_output = fm.score_style(
        ("italic",), ("oblique",)
    )  # 580ns -> 617ns (6.00% slower)
    codeflash_output = fm.score_style(
        ("italic",), "italic"
    )  # 344ns -> 356ns (3.37% slower)


def test_list_input(fm):
    # Test list input
    codeflash_output = fm.score_style(
        ["italic"], ["italic"]
    )  # 700ns -> 726ns (3.58% slower)
    codeflash_output = fm.score_style(
        ["italic"], ["oblique"]
    )  # 680ns -> 623ns (9.15% faster)
    codeflash_output = fm.score_style(
        ["italic"], "italic"
    )  # 385ns -> 335ns (14.9% faster)


def test_dict_input(fm):
    # Test dict input
    codeflash_output = fm.score_style(
        {"style": "italic"}, {"style": "italic"}
    )  # 1.04μs -> 699ns (49.2% faster)
    codeflash_output = fm.score_style(
        {"style": "italic"}, {"style": "oblique"}
    )  # 721ns -> 673ns (7.13% faster)


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


def test_large_batch_exact_matches(fm):
    # Test a large batch of exact matches
    styles = ["normal", "italic", "oblique", "bold", "light", "foo", "", None]
    for style in styles:
        for _ in range(100):
            codeflash_output = fm.score_style(style, style)


def test_large_batch_italic_oblique(fm):
    # Test a large batch of italic-oblique matches
    for _ in range(100):
        codeflash_output = fm.score_style(
            "italic", "oblique"
        )  # 23.4μs -> 21.8μs (7.26% faster)
        codeflash_output = fm.score_style("oblique", "italic")


def test_large_batch_no_matches(fm):
    # Test a large batch of no matches
    styles1 = ["normal", "bold", "light", "foo", "", None]
    styles2 = ["italic", "oblique"]
    for s1 in styles1:
        for s2 in styles2:
            for _ in range(10):
                codeflash_output = fm.score_style(s1, s2)
                codeflash_output = fm.score_style(s2, s1)


def test_performance_large_unique_pairs(fm):
    # Test performance and correctness for many unique pairs
    # (not exceeding 1000 pairs)
    styles = [f"style{i}" for i in range(50)]
    for i in range(len(styles)):
        for j in range(len(styles)):
            expected = 0.0 if styles[i] == styles[j] else 1.0
            codeflash_output = fm.score_style(styles[i], styles[j])


def test_performance_large_italic_oblique_pairs(fm):
    # Test performance and correctness for many 'italic'/'oblique' pairs
    for i in range(500):
        style1 = "italic" if i % 2 == 0 else "oblique"
        style2 = "oblique" if i % 2 == 0 else "italic"
        codeflash_output = fm.score_style(
            style1, style2
        )  # 114μs -> 103μs (10.3% faster)


def test_large_variety_types(fm):
    # Test a large variety of types in batch
    inputs = [
        "italic",
        "oblique",
        "normal",
        "bold",
        "",
        None,
        1,
        0,
        True,
        False,
        ["italic"],
        ("italic",),
        {"style": "italic"},
    ]
    # All pairs where types differ should be 1.0 unless both are 'italic'/'oblique'
    for s1 in inputs:
        for s2 in inputs:
            if s1 == s2:
                codeflash_output = fm.score_style(s1, s2)
            elif s1 in ("italic", "oblique") and s2 in ("italic", "oblique"):
                codeflash_output = fm.score_style(s1, s2)
            else:
                codeflash_output = fm.score_style(s1, s2)


# 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 matplotlib.font_manager import FontManager

# unit tests


@pytest.fixture
def fm():
    # Fixture to provide a FontManager instance for all tests
    return FontManager()


# --- Basic Test Cases ---


def test_exact_match_regular(fm):
    # Test that two identical styles return 0.0
    codeflash_output = fm.score_style(
        "normal", "normal"
    )  # 774ns -> 726ns (6.61% faster)


def test_exact_match_italic(fm):
    # Test that two identical 'italic' styles return 0.0
    codeflash_output = fm.score_style(
        "italic", "italic"
    )  # 792ns -> 679ns (16.6% faster)


def test_exact_match_oblique(fm):
    # Test that two identical 'oblique' styles return 0.0
    codeflash_output = fm.score_style(
        "oblique", "oblique"
    )  # 764ns -> 609ns (25.5% faster)


def test_italic_oblique_match(fm):
    # Test that 'italic' and 'oblique' are considered a close match (0.1)
    codeflash_output = fm.score_style(
        "italic", "oblique"
    )  # 795ns -> 876ns (9.25% slower)
    codeflash_output = fm.score_style(
        "oblique", "italic"
    )  # 371ns -> 339ns (9.44% faster)


def test_no_match_normal_italic(fm):
    # Test that 'normal' and 'italic' are not a close match (1.0)
    codeflash_output = fm.score_style(
        "normal", "italic"
    )  # 857ns -> 840ns (2.02% faster)
    codeflash_output = fm.score_style(
        "italic", "normal"
    )  # 319ns -> 362ns (11.9% slower)


def test_no_match_normal_oblique(fm):
    # Test that 'normal' and 'oblique' are not a close match (1.0)
    codeflash_output = fm.score_style(
        "normal", "oblique"
    )  # 995ns -> 856ns (16.2% faster)
    codeflash_output = fm.score_style(
        "oblique", "normal"
    )  # 385ns -> 378ns (1.85% faster)


def test_no_match_random_strings(fm):
    # Test that unrelated style names are not a match
    codeflash_output = fm.score_style("foo", "bar")  # 878ns -> 908ns (3.30% slower)
    codeflash_output = fm.score_style("bold", "italic")  # 322ns -> 277ns (16.2% faster)
    codeflash_output = fm.score_style("bold", "normal")  # 231ns -> 190ns (21.6% faster)


# --- Edge Test Cases ---


def test_case_sensitivity(fm):
    # Test that the function is case-sensitive
    codeflash_output = fm.score_style(
        "Italic", "italic"
    )  # 923ns -> 798ns (15.7% faster)
    codeflash_output = fm.score_style(
        "Oblique", "oblique"
    )  # 372ns -> 334ns (11.4% faster)
    codeflash_output = fm.score_style(
        "NORMAL", "normal"
    )  # 241ns -> 328ns (26.5% slower)


def test_empty_strings(fm):
    # Test that empty strings do not match anything except themselves
    codeflash_output = fm.score_style("", "")  # 760ns -> 744ns (2.15% faster)
    codeflash_output = fm.score_style("", "normal")  # 436ns -> 447ns (2.46% slower)
    codeflash_output = fm.score_style("normal", "")  # 309ns -> 265ns (16.6% faster)


def test_none_values(fm):
    # Test that None does not match anything except itself
    # (Assuming function supports None, otherwise should raise)
    codeflash_output = fm.score_style(None, None)  # 753ns -> 682ns (10.4% faster)
    codeflash_output = fm.score_style(None, "normal")  # 590ns -> 619ns (4.68% slower)
    codeflash_output = fm.score_style("italic", None)  # 362ns -> 364ns (0.549% slower)


def test_numeric_values(fm):
    # Test numeric input is treated as not matching
    codeflash_output = fm.score_style(0, 0)  # 765ns -> 796ns (3.89% slower)
    codeflash_output = fm.score_style(1, 1)  # 215ns -> 210ns (2.38% faster)
    codeflash_output = fm.score_style(0, 1)  # 563ns -> 519ns (8.48% faster)
    codeflash_output = fm.score_style("italic", 0)  # 367ns -> 370ns (0.811% slower)


def test_mixed_types(fm):
    # Test mixed type input
    codeflash_output = fm.score_style(
        "italic", ["italic"]
    )  # 1.14μs -> 1.01μs (12.8% faster)
    codeflash_output = fm.score_style(
        ["italic"], "italic"
    )  # 316ns -> 345ns (8.41% slower)
    codeflash_output = fm.score_style(
        {"style": "italic"}, {"style": "italic"}
    )  # 429ns -> 693ns (38.1% slower)
    codeflash_output = fm.score_style(
        {"style": "italic"}, {"style": "oblique"}
    )  # 455ns -> 517ns (12.0% slower)


def test_tuple_input(fm):
    # Test tuple input
    codeflash_output = fm.score_style(
        ("italic",), ("italic",)
    )  # 820ns -> 709ns (15.7% faster)
    codeflash_output = fm.score_style(
        ("italic",), ("oblique",)
    )  # 667ns -> 707ns (5.66% slower)


def test_long_strings(fm):
    # Test long string input
    s1 = "italic" * 100
    s2 = "oblique" * 100
    codeflash_output = fm.score_style(s1, s1)  # 785ns -> 591ns (32.8% faster)
    codeflash_output = fm.score_style(s1, s2)  # 419ns -> 368ns (13.9% faster)


# --- Large Scale Test Cases ---


def test_many_unique_pairs(fm):
    # Test many unique style pairs, all should return 1.0 unless identical or italic/oblique
    styles = [
        "normal",
        "italic",
        "oblique",
        "bold",
        "condensed",
        "expanded",
        "ultralight",
        "light",
        "heavy",
    ]
    for i, s1 in enumerate(styles):
        for j, s2 in enumerate(styles):
            if s1 == s2:
                codeflash_output = fm.score_style(s1, s2)
            elif s1 in ("italic", "oblique") and s2 in ("italic", "oblique"):
                codeflash_output = fm.score_style(s1, s2)
            else:
                codeflash_output = fm.score_style(s1, s2)


def test_score_style_performance_large_input(fm):
    # Test performance and correctness with a large number of calls
    # (not real performance, but ensures function does not degrade)
    styles = ["normal", "italic", "oblique", "bold", "condensed"]
    for i in range(200):  # 200*200 = 40000 calls
        s1 = styles[i % len(styles)]
        s2 = styles[(i * 7) % len(styles)]
        # The expected value:
        if s1 == s2:
            expected = 0.0
        elif s1 in ("italic", "oblique") and s2 in ("italic", "oblique"):
            expected = 0.1
        else:
            expected = 1.0
        codeflash_output = fm.score_style(s1, s2)  # 46.7μs -> 40.8μs (14.3% faster)


def test_score_style_all_possible_pairs_under_1000(fm):
    # Test all possible pairs from a large but reasonable set of style names
    base_styles = [
        "normal",
        "italic",
        "oblique",
        "bold",
        "condensed",
        "expanded",
        "ultralight",
        "light",
        "heavy",
        "extra",
    ]
    styles = [f"{b}{i}" for i in range(50) for b in base_styles]  # 500 unique
    # Only identical pairs should match
    for idx, s in enumerate(styles):
        codeflash_output = fm.score_style(s, s)  # 84.6μs -> 83.2μs (1.64% faster)
        if s.startswith("italic"):
            # Should only match 'oblique' with same suffix at 0.1
            oblique = "oblique" + s[len("italic") :]
            if oblique in styles:
                codeflash_output = fm.score_style(
                    s, oblique
                )  # Not exactly 'italic' and 'oblique'
    # Check 'italic' and 'oblique' base
    codeflash_output = fm.score_style(
        "italic", "oblique"
    )  # 336ns -> 323ns (4.02% faster)


# --- Mutation/Robustness Tests ---


def test_mutation_resistance(fm):
    # Changing the return values should break these tests
    # This test ensures that a mutated function (e.g. swapping 0.1 and 1.0) would fail
    codeflash_output = fm.score_style(
        "italic", "oblique"
    )  # 1.01μs -> 755ns (33.5% faster)
    codeflash_output = fm.score_style(
        "oblique", "italic"
    )  # 371ns -> 313ns (18.5% faster)
    codeflash_output = fm.score_style(
        "italic", "italic"
    )  # 204ns -> 217ns (5.99% slower)
    codeflash_output = fm.score_style(
        "oblique", "oblique"
    )  # 166ns -> 160ns (3.75% faster)
    codeflash_output = fm.score_style(
        "normal", "italic"
    )  # 387ns -> 355ns (9.01% faster)
    codeflash_output = fm.score_style(
        "normal", "normal"
    )  # 195ns -> 185ns (5.41% faster)


# 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-FontManager.score_style-miybox03 and push.