⚡️ Speed up function _is_floats_color by 59%

[codeflash-ai]

📄 59% (0.59x) speedup for _is_floats_color in pandas/plotting/_matplotlib/style.py

⏱️ Runtime : 275 microseconds → 173 microseconds (best of 158 runs)

📝 Explanation and details

The optimized version replaces a chained boolean expression with early-return conditional statements, providing a 58% speedup from 275μs to 173μs.

Key Optimization: Early Exit Pattern
The original code used a single return bool(...) statement with and operators that forced evaluation of all conditions even when earlier ones failed. The optimized version uses separate if statements with early returns, allowing the function to exit immediately when any condition fails.

Specific Performance Improvements:

1. Faster failure detection for non-list-like inputs: When is_list_like(color) returns False, the optimized version exits immediately instead of continuing to evaluate length and type checks
2. Eliminated redundant bool() wrapper: The original wrapped the entire expression in bool(), adding unnecessary overhead
3. Replaced expensive all() generator with explicit loop: The all(isinstance(x, (int, float)) for x in color) creates a generator and calls all(), while the explicit for loop with early return is more efficient

Performance Characteristics by Test Case:

• Best improvements (60-90% faster) occur when the function encounters invalid types early in the sequence, as shown in tests with strings, None values, or mixed invalid types
• Moderate improvements (40-60% faster) for valid RGB/RGBA inputs where all conditions must be checked
• Smallest improvements (15-30% faster) for edge cases like empty containers or wrong lengths, where the function still exits early but with less dramatic gains

Impact on Workloads:
The function is called by _is_single_color() in matplotlib plotting style detection. Since this is likely in the rendering pipeline, the 58% speedup will meaningfully improve plot generation performance, especially when processing many color specifications or when invalid colors are frequently encountered (which trigger the fastest exit paths).

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from collections.abc import Collection

# imports
from pandas.plotting._matplotlib.style import _is_floats_color


def is_list_like(obj):
    # Minimal implementation for testing purposes
    return isinstance(obj, Collection) and not isinstance(obj, (str, bytes))


# unit tests

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


def test_basic_rgb_tuple():
    # Standard RGB tuple of floats
    codeflash_output = _is_floats_color(
        (0.1, 0.2, 0.3)
    )  # 2.84μs -> 1.92μs (47.7% faster)


def test_basic_rgba_tuple():
    # Standard RGBA tuple of floats
    codeflash_output = _is_floats_color(
        (0.1, 0.2, 0.3, 0.4)
    )  # 2.71μs -> 1.70μs (59.1% faster)


def test_basic_rgb_list():
    # Standard RGB list of floats
    codeflash_output = _is_floats_color(
        [0.5, 0.6, 0.7]
    )  # 1.89μs -> 1.19μs (58.4% faster)


def test_basic_rgba_list():
    # Standard RGBA list of floats
    codeflash_output = _is_floats_color(
        [0.5, 0.6, 0.7, 0.8]
    )  # 1.93μs -> 1.24μs (55.8% faster)


def test_basic_rgb_tuple_of_ints():
    # RGB tuple of ints
    codeflash_output = _is_floats_color((1, 2, 3))  # 2.35μs -> 1.49μs (58.0% faster)


def test_basic_rgba_tuple_of_ints():
    # RGBA tuple of ints
    codeflash_output = _is_floats_color((1, 2, 3, 4))  # 2.37μs -> 1.56μs (51.7% faster)


def test_basic_rgb_mixed_types():
    # RGB tuple with mixed int and float
    codeflash_output = _is_floats_color((1, 2.0, 3))  # 2.29μs -> 1.44μs (58.3% faster)


def test_basic_rgba_mixed_types():
    # RGBA list with mixed int and float
    codeflash_output = _is_floats_color(
        [1.0, 2, 3.0, 4]
    )  # 2.00μs -> 1.28μs (56.2% faster)


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


def test_edge_empty_list():
    # Empty list should not be a valid color
    codeflash_output = _is_floats_color([])  # 895ns -> 718ns (24.7% faster)


def test_edge_empty_tuple():
    # Empty tuple should not be a valid color
    codeflash_output = _is_floats_color(())  # 1.36μs -> 1.22μs (11.0% faster)


def test_edge_length_two():
    # Length 2 is not valid
    codeflash_output = _is_floats_color((0.1, 0.2))  # 1.34μs -> 1.12μs (19.6% faster)


def test_edge_length_five():
    # Length 5 is not valid
    codeflash_output = _is_floats_color(
        (0.1, 0.2, 0.3, 0.4, 0.5)
    )  # 1.29μs -> 1.06μs (22.2% faster)


def test_edge_non_numeric_elements():
    # Contains a string
    codeflash_output = _is_floats_color(
        (0.1, "red", 0.3)
    )  # 2.65μs -> 1.49μs (78.2% faster)
    # Contains None
    codeflash_output = _is_floats_color(
        [0.1, None, 0.3]
    )  # 1.19μs -> 614ns (93.8% faster)
    # Contains bool
    codeflash_output = _is_floats_color(
        [0.1, True, 0.3]
    )  # 979ns -> 535ns (83.0% faster)


def test_edge_string_input():
    # A string is not list-like for this purpose
    codeflash_output = _is_floats_color("red")  # 934ns -> 732ns (27.6% faster)


def test_edge_bytes_input():
    # Bytes are not valid
    codeflash_output = _is_floats_color(
        b"\x00\x01\x02"
    )  # 1.11μs -> 836ns (32.3% faster)


def test_edge_dict_input():
    # Dict is list-like but not valid color
    codeflash_output = _is_floats_color(
        {0.1: 0.2, 0.3: 0.4}
    )  # 1.33μs -> 1.13μs (17.1% faster)


def test_edge_set_input():
    # Set is list-like but unordered and not valid color
    codeflash_output = _is_floats_color(
        {0.1, 0.2, 0.3}
    )  # 2.54μs -> 1.74μs (45.9% faster)
    codeflash_output = _is_floats_color(
        {0.1, 0.2, 0.3, 0.4}
    )  # 1.22μs -> 801ns (52.4% faster)
    codeflash_output = _is_floats_color({0.1, 0.2})  # 400ns -> 304ns (31.6% faster)
    codeflash_output = _is_floats_color(
        {0.1, 0.2, 0.3, 0.4, 0.5}
    )  # 272ns -> 233ns (16.7% faster)


def test_edge_tuple_with_nan_inf():
    # NaN and inf are floats, so should be accepted
    import math

    codeflash_output = _is_floats_color(
        (math.nan, 0.2, 0.3)
    )  # 2.16μs -> 1.29μs (67.9% faster)
    codeflash_output = _is_floats_color(
        (math.inf, 0.2, 0.3)
    )  # 877ns -> 589ns (48.9% faster)


def test_edge_tuple_with_negative_values():
    # Negative values are allowed
    codeflash_output = _is_floats_color((-1, -2, -3))  # 2.08μs -> 1.27μs (63.5% faster)


def test_edge_tuple_with_zero_values():
    # Zero values are allowed
    codeflash_output = _is_floats_color((0, 0, 0))  # 2.27μs -> 1.40μs (62.2% faster)


def test_edge_tuple_with_large_values():
    # Large values are allowed
    codeflash_output = _is_floats_color(
        (1e10, 2e10, 3e10)
    )  # 2.43μs -> 1.57μs (54.7% faster)


def test_edge_tuple_with_small_values():
    # Very small values are allowed
    codeflash_output = _is_floats_color(
        (1e-10, 2e-10, 3e-10)
    )  # 2.35μs -> 1.47μs (60.2% faster)


def test_edge_tuple_with_bool_values():
    # bool is a subclass of int, but should not be accepted as a color channel
    # Let's check what the function does:
    codeflash_output = _is_floats_color(
        (True, False, 0.3)
    )  # 2.34μs -> 1.47μs (59.0% faster)
    # If you want to exclude bool, you'd need to change the implementation


def test_edge_tuple_with_object():
    # Contains an object
    class Dummy:
        pass

    codeflash_output = _is_floats_color(
        (Dummy(), 0.2, 0.3)
    )  # 2.71μs -> 1.59μs (70.2% faster)


def test_edge_tuple_with_nested_list():
    # Nested list is not valid
    codeflash_output = _is_floats_color(
        ([0.1, 0.2], 0.3, 0.4)
    )  # 2.24μs -> 1.31μs (70.2% faster)


def test_edge_tuple_with_none():
    # None in tuple
    codeflash_output = _is_floats_color(
        (None, 0.2, 0.3)
    )  # 2.23μs -> 1.35μs (65.3% faster)


def test_edge_tuple_with_empty_string():
    # Empty string in tuple
    codeflash_output = _is_floats_color(
        ("", 0.2, 0.3)
    )  # 2.16μs -> 1.33μs (62.4% faster)


def test_edge_tuple_with_complex_numbers():
    # Complex numbers are not valid
    codeflash_output = _is_floats_color(
        (1 + 2j, 0.2, 0.3)
    )  # 2.24μs -> 1.35μs (65.8% faster)


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


def test_large_scale_valid_rgb():
    # Large number of valid RGB tuples
    for i in range(100):
        rgb = (i * 0.01, i * 0.02, i * 0.03)
        codeflash_output = _is_floats_color(rgb)  # 61.0μs -> 37.5μs (62.7% faster)


def test_large_scale_valid_rgba():
    # Large number of valid RGBA tuples
    for i in range(100):
        rgba = [i * 0.01, i * 0.02, i * 0.03, i * 0.04]
        codeflash_output = _is_floats_color(rgba)  # 64.5μs -> 39.6μs (62.8% faster)


def test_large_scale_invalid_length():
    # Tuples/lists of length 1000 should be invalid
    arr = [0.1] * 1000
    codeflash_output = _is_floats_color(arr)  # 928ns -> 789ns (17.6% faster)


def test_large_scale_invalid_types():
    # Large list with all strings
    arr = ["red"] * 3
    codeflash_output = _is_floats_color(arr)  # 1.92μs -> 1.01μs (89.8% faster)
    # Large list with mixed types
    arr = [0.1, "red", 0.3]
    codeflash_output = _is_floats_color(arr)  # 968ns -> 461ns (110% faster)


def test_large_scale_sets():
    # Large set of 3 elements is valid
    arr = set([0.1, 0.2, 0.3])
    codeflash_output = _is_floats_color(arr)  # 2.51μs -> 1.80μs (39.6% faster)
    # Large set of 4 elements is valid
    arr = set([0.1, 0.2, 0.3, 0.4])
    codeflash_output = _is_floats_color(arr)  # 1.18μs -> 770ns (52.7% faster)
    # Large set of 1000 elements is invalid
    arr = set([float(i) for i in range(1000)])
    codeflash_output = _is_floats_color(arr)  # 571ns -> 458ns (24.7% faster)


def test_large_scale_performance():
    # Check that function is fast for large invalid input
    import time

    arr = [0.1] * 999
    start = time.time()
    codeflash_output = _is_floats_color(arr)
    result = codeflash_output  # 860ns -> 725ns (18.6% faster)
    end = time.time()


# --------------------------
# Miscellaneous/Regression
# --------------------------


def test_regression_tuple_of_three_strings():
    # Regression: tuple of three strings is not valid
    codeflash_output = _is_floats_color(
        ("red", "green", "blue")
    )  # 2.33μs -> 1.36μs (71.2% faster)


def test_regression_tuple_of_three_bools():
    # Regression: tuple of three bools is valid (since bool is int)
    codeflash_output = _is_floats_color(
        (True, False, True)
    )  # 2.41μs -> 1.46μs (65.2% faster)


def test_regression_tuple_of_three_none():
    # Regression: tuple of three None is not valid
    codeflash_output = _is_floats_color(
        (None, None, None)
    )  # 2.16μs -> 1.35μs (60.6% faster)


def test_regression_tuple_of_three_lists():
    # Regression: tuple of three lists is not valid
    codeflash_output = _is_floats_color(
        ([1], [2], [3])
    )  # 2.19μs -> 1.37μs (60.0% faster)


def test_regression_tuple_of_three_dicts():
    # Regression: tuple of three dicts is not valid
    codeflash_output = _is_floats_color(({}, {}, {}))  # 2.35μs -> 1.45μs (61.3% faster)


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

# imports
import pytest  # used for our unit tests
from pandas.plotting._matplotlib.style import _is_floats_color


def is_list_like(obj):
    # Minimal implementation for testing purposes
    # Accepts lists, tuples, sets, but not strings or bytes
    if isinstance(obj, (str, bytes)):
        return False
    try:
        iter(obj)
    except TypeError:
        return False
    return hasattr(obj, "__len__")


# unit tests

# 1. Basic Test Cases


def test_tuple_of_three_floats():
    # Standard RGB color as tuple of floats
    codeflash_output = _is_floats_color(
        (0.1, 0.2, 0.3)
    )  # 2.46μs -> 1.47μs (67.7% faster)


def test_list_of_three_ints():
    # Standard RGB color as list of ints
    codeflash_output = _is_floats_color([1, 2, 3])  # 1.87μs -> 1.06μs (75.5% faster)


def test_tuple_of_four_floats():
    # RGBA color as tuple of floats
    codeflash_output = _is_floats_color(
        (0.1, 0.2, 0.3, 0.4)
    )  # 2.58μs -> 1.66μs (56.0% faster)


def test_list_of_four_ints():
    # RGBA color as list of ints
    codeflash_output = _is_floats_color(
        [255, 255, 255, 128]
    )  # 1.96μs -> 1.14μs (71.9% faster)


def test_tuple_of_three_mixed_int_float():
    # RGB color as tuple with mixed int and float
    codeflash_output = _is_floats_color((0, 0.5, 1))  # 2.33μs -> 1.53μs (52.8% faster)


def test_list_of_four_mixed_int_float():
    # RGBA color as list with mixed int and float
    codeflash_output = _is_floats_color(
        [1.0, 2, 3.5, 4]
    )  # 2.03μs -> 1.21μs (67.4% faster)


# 2. Edge Test Cases


def test_list_of_two_floats():
    # Only two elements, should be False
    codeflash_output = _is_floats_color([0.1, 0.2])  # 859ns -> 700ns (22.7% faster)


def test_list_of_five_floats():
    # Five elements, should be False
    codeflash_output = _is_floats_color(
        [0.1, 0.2, 0.3, 0.4, 0.5]
    )  # 858ns -> 694ns (23.6% faster)


def test_empty_list():
    # Empty list, should be False
    codeflash_output = _is_floats_color([])  # 804ns -> 700ns (14.9% faster)


def test_single_float():
    # Single float, not list-like of length 3 or 4
    codeflash_output = _is_floats_color(0.5)  # 925ns -> 714ns (29.6% faster)


def test_string_input():
    # String input, not list-like for our purposes
    codeflash_output = _is_floats_color("red")  # 1.03μs -> 829ns (23.9% faster)


def test_tuple_of_three_strings():
    # Tuple of strings, not all int/float
    codeflash_output = _is_floats_color(
        ("r", "g", "b")
    )  # 2.58μs -> 1.48μs (74.3% faster)


def test_tuple_of_three_floats_and_string():
    # Tuple with a string among numbers
    codeflash_output = _is_floats_color(
        (0.1, 0.2, "b")
    )  # 2.61μs -> 1.61μs (62.4% faster)


def test_tuple_of_three_bools():
    # Tuple of bools, which are subclasses of int, so should be True
    codeflash_output = _is_floats_color(
        (True, False, True)
    )  # 2.35μs -> 1.44μs (63.9% faster)


def test_tuple_of_three_None():
    # Tuple of None, not int/float
    codeflash_output = _is_floats_color(
        (None, None, None)
    )  # 2.27μs -> 1.31μs (73.6% faster)


def test_tuple_of_three_objects():
    # Tuple of objects, not int/float
    codeflash_output = _is_floats_color(
        (object(), object(), object())
    )  # 2.23μs -> 1.30μs (71.7% faster)


def test_set_of_three_floats():
    # Set of three floats, should be True (since set is list-like and has length)
    codeflash_output = _is_floats_color(
        {0.1, 0.2, 0.3}
    )  # 2.56μs -> 1.66μs (54.4% faster)


def test_dict_of_three_floats():
    # Dict is list-like and has length, but keys are ints/floats
    # Iterating over dict yields keys, so if all keys are int/float, should be True
    codeflash_output = _is_floats_color(
        {1: "a", 2: "b", 3: "c"}
    )  # 2.22μs -> 1.45μs (53.3% faster)


def test_dict_with_non_numeric_keys():
    # Dict with a non-numeric key, should be False
    codeflash_output = _is_floats_color(
        {"a": 1, 2: 2, 3: 3}
    )  # 2.42μs -> 1.35μs (78.5% faster)


def test_tuple_of_three_nan():
    # Tuple of three float('nan'), should be True
    codeflash_output = _is_floats_color(
        (float("nan"), float("nan"), float("nan"))
    )  # 2.38μs -> 1.41μs (69.1% faster)


def test_tuple_of_three_inf():
    # Tuple of three float('inf'), should be True
    codeflash_output = _is_floats_color(
        (float("inf"), float("-inf"), 0.0)
    )  # 2.24μs -> 1.41μs (58.7% faster)


def test_bytes_input():
    # Bytes input, not list-like for our purposes
    codeflash_output = _is_floats_color(
        b"\x00\x01\x02"
    )  # 1.10μs -> 891ns (23.8% faster)


def test_tuple_of_three_complex():
    # Complex numbers are not int or float
    codeflash_output = _is_floats_color(
        (1 + 2j, 3 + 4j, 5 + 6j)
    )  # 3.64μs -> 2.27μs (60.0% faster)


# 3. Large Scale Test Cases


def test_large_list_of_999_floats():
    # Large list (length 999), should be False
    codeflash_output = _is_floats_color(
        [float(i) for i in range(999)]
    )  # 1.14μs -> 868ns (31.6% faster)


def test_large_list_of_3_floats():
    # Large values but only 3 elements, should be True
    big = 1e100
    codeflash_output = _is_floats_color(
        [big, big, big]
    )  # 2.12μs -> 1.25μs (69.2% faster)


def test_large_list_of_4_floats():
    # Large values, 4 elements, should be True
    big = 1e100
    codeflash_output = _is_floats_color(
        [big, big, big, big]
    )  # 2.17μs -> 1.31μs (65.3% faster)


def test_large_set_of_3_floats():
    # Set of 3 large floats, should be True
    big = 1e100
    codeflash_output = _is_floats_color(
        {big, big + 1, big + 2}
    )  # 1.69μs -> 1.29μs (31.1% faster)


def test_large_tuple_of_4_ints():
    # Tuple of 4 large ints, should be True
    big = 10**18
    codeflash_output = _is_floats_color(
        (big, big, big, big)
    )  # 2.43μs -> 1.59μs (53.2% faster)


def test_large_dict_of_3_floats():
    # Dict with 3 large float keys, should be True
    big = 1e100
    codeflash_output = _is_floats_color(
        {big: 1, big + 1: 2, big + 2: 3}
    )  # 1.49μs -> 1.26μs (17.5% faster)


def test_large_dict_of_4_non_numeric_keys():
    # Dict with 4 non-numeric keys, should be False
    codeflash_output = _is_floats_color(
        {"a": 1, "b": 2, "c": 3, "d": 4}
    )  # 2.38μs -> 1.47μs (61.6% faster)


# Additional edge cases


def test_tuple_of_three_bool_and_int():
    # Tuple with bool and int, should be True
    codeflash_output = _is_floats_color((True, 1, 0))  # 2.38μs -> 1.54μs (55.1% faster)


def test_tuple_of_three_decimal():
    # Tuple with Decimal, should be False (Decimal is not int/float)
    from decimal import Decimal

    codeflash_output = _is_floats_color(
        (Decimal("1.1"), Decimal("2.2"), Decimal("3.3"))
    )  # 2.39μs -> 1.43μs (67.5% faster)


def test_tuple_of_three_numpy_float():
    # Tuple with numpy.float64, should be False (not int/float)
    try:
        import numpy as np

        codeflash_output = _is_floats_color(
            (np.float64(1.1), np.float64(2.2), np.float64(3.3))
        )
        result = codeflash_output
    except ImportError:
        pytest.skip("numpy not installed")


# 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-_is_floats_color-mir27r1i and push.