⚡️ Speed up function _get_colors_from_color by 188%

[codeflash-ai]

📄 188% (1.88x) speedup for _get_colors_from_color in pandas/plotting/_matplotlib/style.py

⏱️ Runtime : 6.66 milliseconds → 2.31 milliseconds (best of 220 runs)

📝 Explanation and details

The optimization achieves a 187% speedup by addressing the primary bottleneck: expensive matplotlib color string validation that's called repeatedly for the same color strings.

Key optimization: LRU caching for color string validation

• Added @lru_cache(maxsize=256) to cache _is_single_string_color results
• This function calls matplotlib's ColorConverter.to_rgba(), which is expensive but deterministic
• The cache dramatically reduces repeated validation costs for common colors like "red", "C0", etc.

Performance impact by test type:

• String colors see massive gains: Single color strings improve 200-2600% (e.g., "C3" from 11.3μs to 1.07μs)
• Large string-heavy workloads benefit most: 1000 C-colors improved 2666% (2.60ms → 93.9μs)
• Float tuple colors remain unchanged: RGB/RGBA tuples show minimal impact since they bypass the cached path
• Invalid color detection accelerates: Error cases improve 200-400% due to cached negative results

Why this works:

• Color strings are typically reused heavily in plotting (same palette, repeated series colors)
• The cache hit rate is high in real workloads, turning O(n) matplotlib validations into O(1) lookups
• String validation dominates runtime (72% of time in _is_single_color per profiler)

Context impact:
Based on function_references, this function is called by _derive_colors() which handles color derivation for matplotlib plotting. Since plotting often reuses the same color palette across multiple series/charts, the caching will be particularly effective in typical pandas visualization workflows where the same colors appear repeatedly.

The minor empty check optimization (not color or len(color) == 0) provides small additional gains for edge cases while maintaining identical behavior.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations


# imports
import pytest
from pandas.plotting._matplotlib.style import _get_colors_from_color

# unit tests

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


def test_named_color_string():
    # Single named color string
    codeflash_output = _get_colors_from_color("red")  # 3.14μs -> 1.03μs (204% faster)
    codeflash_output = _get_colors_from_color("g")  # 1.10μs -> 443ns (147% faster)
    codeflash_output = _get_colors_from_color("C1")  # 7.38μs -> 350ns (2009% faster)
    codeflash_output = _get_colors_from_color(
        "firebrick"
    )  # 1.01μs -> 309ns (226% faster)


def test_single_rgb_tuple():
    # Single RGB tuple (all floats)
    codeflash_output = _get_colors_from_color(
        (0.1, 0.2, 0.3)
    )  # 3.18μs -> 3.17μs (0.189% faster)
    # Single RGBA tuple (all floats)
    codeflash_output = _get_colors_from_color(
        (0.1, 0.2, 0.3, 0.4)
    )  # 1.27μs -> 1.36μs (6.69% slower)
    # Single RGB tuple (all ints)
    codeflash_output = _get_colors_from_color(
        (1, 2, 3)
    )  # 856ns -> 835ns (2.51% faster)
    # Single RGBA tuple (all ints)
    codeflash_output = _get_colors_from_color(
        (1, 2, 3, 4)
    )  # 800ns -> 823ns (2.79% slower)


def test_list_of_named_colors():
    # List of valid color strings
    codeflash_output = _get_colors_from_color(
        ["red", "blue", "green"]
    )  # 7.42μs -> 3.98μs (86.5% faster)
    # Tuple of valid color strings
    codeflash_output = _get_colors_from_color(
        ("red", "blue", "green")
    )  # 3.68μs -> 2.31μs (59.4% faster)


def test_list_of_rgb_tuples():
    # List of valid RGB tuples
    colors = [(0.1, 0.2, 0.3), (0.4, 0.5, 0.6)]
    codeflash_output = _get_colors_from_color(colors)  # 4.09μs -> 4.46μs (8.24% slower)


def test_mixed_valid_colors():
    # List of mixed valid color strings and tuples
    colors = ["red", (0.1, 0.2, 0.3), "blue", (0.4, 0.5, 0.6, 0.7)]
    codeflash_output = _get_colors_from_color(colors)  # 9.09μs -> 5.83μs (55.8% faster)


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


def test_empty_string():
    # Empty string is not a valid color
    with pytest.raises(ValueError):
        _get_colors_from_color("")  # 1.01μs -> 879ns (15.4% faster)


def test_empty_list():
    # Empty list should raise ValueError
    with pytest.raises(ValueError):
        _get_colors_from_color([])  # 1.36μs -> 1.23μs (10.8% faster)


def test_empty_tuple():
    # Empty tuple should raise ValueError
    with pytest.raises(ValueError):
        _get_colors_from_color(())  # 1.27μs -> 1.20μs (5.85% faster)


def test_invalid_color_string():
    # Invalid color string should raise ValueError
    with pytest.raises(ValueError):
        _get_colors_from_color("notacolor")  # 21.1μs -> 4.29μs (392% faster)


def test_list_with_invalid_color():
    # List with one invalid color should raise ValueError
    with pytest.raises(ValueError):
        _get_colors_from_color(
            ["red", "notacolor", "blue"]
        )  # 16.0μs -> 5.38μs (198% faster)


def test_tuple_with_invalid_color():
    # Tuple with one invalid color should raise ValueError
    with pytest.raises(ValueError):
        _get_colors_from_color(
            ("red", "notacolor", "blue")
        )  # 16.1μs -> 5.45μs (196% faster)


def test_list_with_invalid_rgb_tuple():
    # List with one invalid RGB tuple (wrong length)
    with pytest.raises(ValueError):
        _get_colors_from_color(
            [(0.1, 0.2), (0.3, 0.4, 0.5)]
        )  # 6.47μs -> 6.66μs (2.85% slower)


def test_tuple_with_non_numeric_rgb():
    # Tuple with non-numeric values
    with pytest.raises(ValueError):
        _get_colors_from_color((0.1, "a", 0.3))  # 6.03μs -> 6.48μs (6.87% slower)


def test_list_with_non_numeric_rgb():
    # List with one non-numeric RGB tuple
    with pytest.raises(ValueError):
        _get_colors_from_color(
            [(0.1, 0.2, 0.3), (0.1, "b", 0.3)]
        )  # 8.26μs -> 8.38μs (1.44% slower)


def test_string_of_multiple_letters():
    # String of multiple letters should be interpreted as a single color if valid
    codeflash_output = _get_colors_from_color("blue")  # 3.98μs -> 1.08μs (268% faster)
    # But a string of multiple letters that is not a color should raise
    with pytest.raises(ValueError):
        _get_colors_from_color("xyz")  # 17.6μs -> 3.36μs (423% faster)


def test_generator_input():
    # Generator of valid colors
    colors = (c for c in ["red", "green", "blue"])
    codeflash_output = _get_colors_from_color(
        list(colors)
    )  # 6.97μs -> 3.86μs (80.4% faster)


def test_tuple_of_rgb_and_color_string():
    # Tuple of a valid RGB tuple and a valid color string
    colors = ((0.1, 0.2, 0.3), "red")
    codeflash_output = _get_colors_from_color(colors)  # 6.46μs -> 4.61μs (40.2% faster)


def test_tuple_of_invalid_length():
    # Tuple of length 2 is not a valid color
    with pytest.raises(ValueError):
        _get_colors_from_color((0.1, 0.2))  # 5.29μs -> 5.44μs (2.76% slower)


def test_list_of_empty_strings():
    # List of empty strings is invalid
    with pytest.raises(ValueError):
        _get_colors_from_color(["", ""])  # 14.5μs -> 3.80μs (280% faster)


def test_nested_list_colors():
    # Nested list is not supported
    with pytest.raises(ValueError):
        _get_colors_from_color(
            [["red", "blue"], "green"]
        )  # 4.68μs -> 4.68μs (0.107% slower)


def test_non_iterable_input():
    # Non-iterable input (int, float, bool) should raise TypeError
    with pytest.raises(TypeError):
        _get_colors_from_color(123)  # 1.14μs -> 1.15μs (0.955% slower)
    with pytest.raises(TypeError):
        _get_colors_from_color(0.5)  # 667ns -> 729ns (8.50% slower)
    with pytest.raises(TypeError):
        _get_colors_from_color(True)  # 471ns -> 556ns (15.3% slower)


def test_bytes_input():
    # Bytes input is not a valid color
    with pytest.raises(ValueError):
        _get_colors_from_color(b"red")  # 3.79μs -> 4.05μs (6.44% slower)


def test_tuple_with_extra_elements():
    # Tuple with more than 4 elements is not a valid color
    with pytest.raises(ValueError):
        _get_colors_from_color(
            (0.1, 0.2, 0.3, 0.4, 0.5)
        )  # 5.55μs -> 5.81μs (4.49% slower)


def test_tuple_with_less_than_3_elements():
    # Tuple with less than 3 elements is not a valid color
    with pytest.raises(ValueError):
        _get_colors_from_color((0.1, 0.2))  # 5.04μs -> 5.28μs (4.60% slower)


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


def test_large_list_of_named_colors():
    # Large list of named colors
    colors = ["red", "green", "blue"] * 300  # 900 items
    codeflash_output = _get_colors_from_color(colors)  # 380μs -> 76.0μs (401% faster)


def test_large_list_of_rgb_tuples():
    # Large list of RGB tuples
    colors = [(i / 255.0, i / 255.0, i / 255.0) for i in range(900)]
    codeflash_output = _get_colors_from_color(colors)  # 376μs -> 378μs (0.504% slower)


def test_large_list_with_one_invalid():
    # Large list with one invalid color at the end
    colors = ["red"] * 999 + ["notacolor"]
    with pytest.raises(ValueError):
        _get_colors_from_color(colors)  # 439μs -> 83.4μs (428% faster)


def test_large_list_of_mixed_colors():
    # Large list of mixed valid color strings and tuples
    colors = []
    for i in range(500):
        colors.append("red")
        colors.append((i / 255.0, i / 255.0, i / 255.0))
    codeflash_output = _get_colors_from_color(colors)  # 466μs -> 260μs (79.3% faster)


def test_large_list_of_rgba_tuples():
    # Large list of RGBA tuples
    colors = [(i / 255.0, i / 255.0, i / 255.0, 0.5) for i in range(900)]
    codeflash_output = _get_colors_from_color(colors)  # 434μs -> 438μs (0.984% slower)


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

from __future__ import annotations


# imports
import pytest
from pandas.plotting._matplotlib.style import _get_colors_from_color

# unit tests

# 1. Basic Test Cases


def test_single_named_color():
    # Should return a list with the same color string
    codeflash_output = _get_colors_from_color("red")  # 4.19μs -> 1.31μs (220% faster)


def test_single_alias_color():
    # Should return a list with the alias color
    codeflash_output = _get_colors_from_color("g")  # 3.50μs -> 1.14μs (208% faster)


def test_single_C_number_color():
    # Should return a list with the matplotlib C color
    codeflash_output = _get_colors_from_color("C3")  # 11.3μs -> 1.07μs (954% faster)


def test_single_rgb_tuple():
    # Should return a list with the same tuple
    codeflash_output = _get_colors_from_color(
        (0.1, 0.2, 0.3)
    )  # 3.39μs -> 3.56μs (4.75% slower)


def test_single_rgba_tuple():
    # Should return a list with the same tuple
    codeflash_output = _get_colors_from_color(
        (0.1, 0.2, 0.3, 0.4)
    )  # 2.79μs -> 3.08μs (9.60% slower)


def test_list_of_named_colors():
    # Should return a list with all the named colors
    codeflash_output = _get_colors_from_color(
        ["red", "blue", "green"]
    )  # 7.84μs -> 4.20μs (86.7% faster)


def test_list_of_rgb_tuples():
    # Should return a list with all the tuples
    colors = [(0.1, 0.2, 0.3), (0.4, 0.5, 0.6)]
    codeflash_output = _get_colors_from_color(colors)  # 4.69μs -> 4.92μs (4.77% slower)


def test_mixed_list_of_colors():
    # Should return a list with all valid colors (mix of strings and tuples)
    colors = ["red", (0.1, 0.2, 0.3), "C1"]
    codeflash_output = _get_colors_from_color(colors)  # 16.4μs -> 5.29μs (211% faster)


# 2. Edge Test Cases


def test_empty_string_color():
    # Should raise ValueError for empty string
    with pytest.raises(ValueError):
        _get_colors_from_color("")  # 949ns -> 876ns (8.33% faster)


def test_empty_list():
    # Should raise ValueError for empty list
    with pytest.raises(ValueError):
        _get_colors_from_color([])  # 1.34μs -> 1.17μs (14.6% faster)


def test_empty_tuple():
    # Should raise ValueError for empty tuple
    with pytest.raises(ValueError):
        _get_colors_from_color(())  # 1.36μs -> 1.18μs (14.9% faster)


def test_invalid_string_color():
    # Should raise ValueError for invalid color string
    with pytest.raises(ValueError):
        _get_colors_from_color("notacolor")  # 21.4μs -> 4.38μs (390% faster)


def test_invalid_tuple_length():
    # Should raise ValueError for tuple of wrong length
    with pytest.raises(ValueError):
        _get_colors_from_color((0.1, 0.2))  # 5.82μs -> 6.25μs (6.93% slower)


def test_invalid_tuple_types():
    # Should raise ValueError for tuple with non-numeric types
    with pytest.raises(ValueError):
        _get_colors_from_color(("red", 0.2, 0.3))  # 10.0μs -> 7.28μs (37.6% faster)


def test_list_with_invalid_color():
    # Should raise ValueError if any element in the list is invalid
    with pytest.raises(ValueError):
        _get_colors_from_color(
            ["red", "notacolor", "blue"]
        )  # 17.3μs -> 5.04μs (243% faster)


def test_tuple_of_strings():
    # Should treat as a sequence of colors, not a single color, and raise ValueError if any are invalid
    with pytest.raises(ValueError):
        _get_colors_from_color(
            ("red", "notacolor", "blue")
        )  # 15.7μs -> 5.18μs (204% faster)


def test_string_of_multiple_letters():
    # Should treat as a single color string, and raise ValueError if not a valid color
    with pytest.raises(ValueError):
        _get_colors_from_color("xyz")  # 18.0μs -> 3.56μs (406% faster)


def test_tuple_of_valid_colors():
    # Should treat as a sequence of colors if tuple of strings
    codeflash_output = _get_colors_from_color(
        ("red", "green", "blue")
    )  # 7.52μs -> 4.36μs (72.5% faster)


def test_tuple_of_rgb_and_string():
    # Should work if all are valid single colors
    codeflash_output = _get_colors_from_color(
        [(0.1, 0.2, 0.3), "red"]
    )  # 6.37μs -> 4.36μs (45.9% faster)


def test_nested_list_of_colors():
    # Should raise ValueError for nested lists (not supported)
    with pytest.raises(ValueError):
        _get_colors_from_color(
            [["red", "blue"], "green"]
        )  # 4.59μs -> 4.53μs (1.43% faster)


def test_non_iterable_input():
    # Should raise TypeError for non-iterable input (e.g., int)
    with pytest.raises(TypeError):
        _get_colors_from_color(123)  # 1.19μs -> 1.17μs (1.63% faster)


def test_tuple_of_length_5():
    # Should raise ValueError for tuple of length 5
    with pytest.raises(ValueError):
        _get_colors_from_color(
            (0.1, 0.2, 0.3, 0.4, 0.5)
        )  # 5.85μs -> 6.17μs (5.22% slower)


def test_list_of_empty_strings():
    # Should raise ValueError for empty string in list
    with pytest.raises(ValueError):
        _get_colors_from_color(["red", "", "blue"])  # 17.3μs -> 5.21μs (232% faster)


# 3. Large Scale Test Cases


def test_large_list_of_named_colors():
    # Should handle a large list of valid named colors
    colors = [
        "red",
        "green",
        "blue",
        "cyan",
        "magenta",
        "yellow",
        "black",
        "white",
    ] * 100
    codeflash_output = _get_colors_from_color(colors)
    result = codeflash_output  # 343μs -> 70.6μs (386% faster)


def test_large_list_of_rgb_tuples():
    # Should handle a large list of valid rgb tuples
    colors = [(i / 1000, i / 1000, i / 1000) for i in range(1000)]
    codeflash_output = _get_colors_from_color(colors)
    result = codeflash_output  # 419μs -> 422μs (0.633% slower)


def test_large_mixed_color_list():
    # Should handle a large list of mixed valid color types
    colors = ["red", (0.1, 0.2, 0.3), "blue", (0.4, 0.5, 0.6)] * 200
    codeflash_output = _get_colors_from_color(colors)
    result = codeflash_output  # 377μs -> 209μs (80.0% faster)


def test_large_list_with_one_invalid_color():
    # Should raise ValueError if any color in a large list is invalid
    colors = ["red"] * 999 + ["notacolor"]
    with pytest.raises(ValueError):
        _get_colors_from_color(colors)  # 439μs -> 85.9μs (412% faster)


def test_large_list_of_C_colors():
    # Should handle a large list of C0-C9 colors
    colors = [f"C{i % 10}" for i in range(1000)]
    codeflash_output = _get_colors_from_color(colors)
    result = codeflash_output  # 2.60ms -> 93.9μs (2666% 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-_get_colors_from_color-mir1nwns and push.