⚡️ Speed up method Colors.hex2rgb by 89%

[codeflash-ai]

📄 89% (0.89x) speedup for Colors.hex2rgb in ultralytics/utils/plotting.py

⏱️ Runtime : 1.62 milliseconds → 859 microseconds (best of 76 runs)

📝 Explanation and details

The optimized code achieves an 88% speedup by eliminating Python generator expression overhead in the hex2rgb function and streamlining the palette initialization.

Key optimizations:

1. Removed generator expression overhead: The original hex2rgb used tuple(int(h[1 + i : 1 + i + 2], 16) for i in (0, 2, 4)) which creates a generator, iterates through it, and converts to tuple. The optimized version uses direct tuple construction (int(h[1:3], 16), int(h[3:5], 16), int(h[5:7], 16)), eliminating the generator overhead and reducing function call complexity.

2. Inlined palette conversion: During Colors.__init__(), instead of calling self.hex2rgb() for each color, the optimized version directly performs the hex-to-RGB conversion inline: (int(c[0:2], 16), int(c[2:4], 16), int(c[4:6], 16)). This removes 20 function calls during initialization.

Why this speeds up execution:

• Generator expressions in Python have overhead for iterator creation and __next__() calls
• Direct tuple construction is faster than tuple() conversion
• Inlined operations avoid function call overhead during object initialization
• The line profiler shows the optimized hex2rgb executes in 2.66ms vs 4.82ms for the original (45% faster)

Performance characteristics:
The optimizations are most effective for:

• Frequent Colors object creation (benefits from faster initialization)
• Repeated hex2rgb calls (benefits from direct tuple construction)
• The test results show consistent 80-90% speedups across all hex conversion scenarios, indicating the optimization works well for both valid inputs and error cases

The optimized version maintains identical functionality and error handling while delivering substantial performance gains through reduced Python interpreter overhead.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from ultralytics.utils.plotting import Colors

# ------------------------
# Unit tests for hex2rgb
# ------------------------

# 1. BASIC TEST CASES


@pytest.mark.parametrize(
    "hex_str,expected",
    [
        ("#000000", (0, 0, 0)),  # black
        ("#FFFFFF", (255, 255, 255)),  # white
        ("#ff0000", (255, 0, 0)),  # red (lowercase)
        ("#00FF00", (0, 255, 0)),  # green (uppercase)
        ("#0000FF", (0, 0, 255)),  # blue (uppercase)
        ("#123456", (18, 52, 86)),  # arbitrary value
        ("#abcdef", (171, 205, 239)),  # arbitrary value, lowercase
        ("#42AFFE", (66, 175, 254)),  # arbitrary value, mixed case
    ],
)
def test_hex2rgb_basic(hex_str, expected):
    # Test that typical 6-digit hex strings are converted correctly
    codeflash_output = Colors.hex2rgb(hex_str)  # 14.5μs -> 7.91μs (83.8% faster)


# 2. EDGE TEST CASES


@pytest.mark.parametrize(
    "hex_str,expected",
    [
        ("#000000", (0, 0, 0)),  # minimum value
        ("#ffffff", (255, 255, 255)),  # maximum value, lowercase
        ("#FFFfff", (255, 255, 255)),  # maximum value, mixed case
        ("#010203", (1, 2, 3)),  # lowest nonzero values
        ("#00ff00", (0, 255, 0)),  # green, lowercase
        ("#FF00FF", (255, 0, 255)),  # magenta
        ("#7f7f7f", (127, 127, 127)),  # mid-gray
    ],
)
def test_hex2rgb_edge_valid(hex_str, expected):
    # Test edge valid values and case insensitivity
    codeflash_output = Colors.hex2rgb(hex_str)  # 13.0μs -> 6.97μs (86.0% faster)


@pytest.mark.parametrize(
    "hex_str",
    [
        "",  # empty string
        "#12345",  # too short
        "#1234567",  # too long
        "123456",  # missing '#'
        "#12G456",  # invalid hex char
        "#12",  # way too short
        "#123",  # only 3 digits
        "#ghijkl",  # all invalid chars
        "#FFFFF",  # 5 digits
        "#FFFFFZ",  # invalid last char
        "##123456",  # double hash
        "# 123456",  # space after hash
        None,  # NoneType
        123456,  # int
        "#",  # just hash
    ],
)
def test_hex2rgb_edge_invalid(hex_str):
    # Test invalid hex strings raise ValueError or TypeError
    with pytest.raises((ValueError, TypeError)):
        Colors.hex2rgb(hex_str)  # 35.3μs -> 25.3μs (39.7% faster)


def test_hex2rgb_type_and_length():
    # Test that the result is always a tuple of length 3, with ints 0-255
    codeflash_output = Colors.hex2rgb("#A1B2C3")
    result = codeflash_output  # 2.30μs -> 1.27μs (81.6% faster)
    for c in result:
        pass


def test_hex2rgb_no_side_effects():
    # The function should not modify its input
    s = "#123456"
    Colors.hex2rgb(s)  # 1.80μs -> 940ns (92.0% faster)


# 3. LARGE SCALE TEST CASES


def test_hex2rgb_large_scale_unique():
    # Test conversion of 1000 unique hex values, all valid
    for i in range(1000):
        r = i % 256
        g = (i * 3) % 256
        b = (i * 7) % 256
        hex_str = f"#{r:02x}{g:02x}{b:02x}"
        expected = (r, g, b)
        codeflash_output = Colors.hex2rgb(hex_str)  # 688μs -> 359μs (91.7% faster)


def test_hex2rgb_large_scale_randomized():
    # Test conversion of 500 random valid hex values (using a deterministic sequence)
    for i in range(500):
        r = (i * 31 + 17) % 256
        g = (i * 47 + 23) % 256
        b = (i * 59 + 31) % 256
        hex_str = f"#{r:02X}{g:02X}{b:02X}"  # uppercase
        expected = (r, g, b)
        codeflash_output = Colors.hex2rgb(hex_str)  # 346μs -> 181μs (91.4% faster)


def test_hex2rgb_large_scale_case_insensitivity():
    # Test that upper/lower/mixed case hex digits all work the same
    for i in range(100):
        r = (i * 5) % 256
        g = (i * 13) % 256
        b = (i * 17) % 256
        hex_str = f"#{r:02x}{g:02X}{b:02x}"  # mixed case
        expected = (r, g, b)
        codeflash_output = Colors.hex2rgb(hex_str)  # 71.7μs -> 37.4μs (91.8% faster)


def test_hex2rgb_large_scale_invalid():
    # Test that 100 invalid hex strings all raise
    for i in range(100):
        # Create various invalid strings
        if i % 4 == 0:
            s = f"#{i:06d}"  # contains non-hex digits
        elif i % 4 == 1:
            s = "#" + "".join(chr(65 + ((i + j) % 26)) for j in range(6))  # random letters, some not hex
        elif i % 4 == 2:
            s = "#12345"  # too short
        else:
            s = "#1234567"  # too long
        with pytest.raises((ValueError, TypeError)):
            Colors.hex2rgb(s)


# 4. ADDITIONAL EDGE CASES


def test_hex2rgb_leading_trailing_whitespace():
    # Whitespace should cause ValueError
    with pytest.raises(ValueError):
        Colors.hex2rgb(" #123456")
    with pytest.raises(ValueError):
        Colors.hex2rgb("#123456 ")
    with pytest.raises(ValueError):
        Colors.hex2rgb("  #123456  ")


def test_hex2rgb_non_string_input():
    # Non-string inputs should raise TypeError
    for bad in [None, 123456, 12.34, True, [1, 2, 3], {"hex": "#123456"}]:
        with pytest.raises(TypeError):
            Colors.hex2rgb(bad)


def test_hex2rgb_input_is_bytes():
    # Bytes input should raise TypeError
    with pytest.raises(TypeError):
        Colors.hex2rgb(b"#123456")


def test_hex2rgb_correctness_against_palette():
    # Cross-check known Ultralytics palette entries
    palette = [
        ("#042AFF", (4, 42, 255)),
        ("#0BDBEB", (11, 219, 235)),
        ("#F3F3F3", (243, 243, 243)),
        ("#00DFB7", (0, 223, 183)),
        ("#111F68", (17, 31, 104)),
        ("#FF6FDD", (255, 111, 221)),
        ("#FF444F", (255, 68, 79)),
        ("#CCED00", (204, 237, 0)),
        ("#00F344", (0, 243, 68)),
        ("#BD00FF", (189, 0, 255)),
        ("#00B4FF", (0, 180, 255)),
        ("#DD00BA", (221, 0, 186)),
        ("#00FFFF", (0, 255, 255)),
        ("#26C000", (38, 192, 0)),
        ("#01FFB3", (1, 255, 179)),
        ("#7D24FF", (125, 36, 255)),
        ("#7B0068", (123, 0, 104)),
        ("#FF1B6C", (255, 27, 108)),
        ("#FC6D2F", (252, 109, 47)),
        ("#A2FF0B", (162, 255, 11)),
    ]
    for hex_str, expected in palette:
        codeflash_output = Colors.hex2rgb(hex_str)  # 16.6μs -> 9.03μs (83.5% faster)


# 5. FUNCTIONALITY AND CONTRACT


def test_hex2rgb_tuple_is_immutable():
    # The returned tuple should be immutable
    codeflash_output = Colors.hex2rgb("#123456")
    rgb = codeflash_output  # 1.75μs -> 837ns (109% faster)
    with pytest.raises(TypeError):
        rgb[0] = 99


def test_hex2rgb_does_not_accept_3_digit_hex():
    # 3-digit shorthand hex is not supported
    with pytest.raises(ValueError):
        Colors.hex2rgb("#123")  # 4.17μs -> 3.23μs (29.1% faster)


# 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 ultralytics.utils.plotting import Colors

# unit tests

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


def test_basic_valid_hex_with_hash():
    # Test standard hex with '#'
    codeflash_output = Colors.hex2rgb("#FF0000")  # 2.21μs -> 1.19μs (85.0% faster)
    codeflash_output = Colors.hex2rgb("#00FF00")  # 1.09μs -> 543ns (101% faster)
    codeflash_output = Colors.hex2rgb("#0000FF")  # 800ns -> 429ns (86.5% faster)
    codeflash_output = Colors.hex2rgb("#FFFFFF")  # 782ns -> 422ns (85.3% faster)
    codeflash_output = Colors.hex2rgb("#000000")  # 749ns -> 387ns (93.5% faster)


def test_basic_valid_hex_without_hash():
    # Test standard hex without '#'
    codeflash_output = Colors.hex2rgb("FF0000")  # 1.76μs -> 1.00μs (76.3% faster)
    codeflash_output = Colors.hex2rgb("00FF00")  # 1.01μs -> 509ns (99.2% faster)
    codeflash_output = Colors.hex2rgb("0000FF")  # 852ns -> 481ns (77.1% faster)
    codeflash_output = Colors.hex2rgb("FFFFFF")  # 808ns -> 395ns (105% faster)
    codeflash_output = Colors.hex2rgb("000000")  # 713ns -> 393ns (81.4% faster)


def test_basic_valid_hex_mixed_case():
    # Test hex with mixed case letters
    codeflash_output = Colors.hex2rgb("#fF00fF")  # 1.69μs -> 811ns (109% faster)
    codeflash_output = Colors.hex2rgb("FfFfFf")  # 973ns -> 525ns (85.3% faster)
    codeflash_output = Colors.hex2rgb("aBc123")  # 754ns -> 400ns (88.5% faster)


def test_edge_invalid_length():
    # Test hex color with invalid length
    with pytest.raises(ValueError):
        Colors.hex2rgb("#FFF")  # Too short
    with pytest.raises(ValueError):
        Colors.hex2rgb("1234567")  # Too long
    with pytest.raises(ValueError):
        Colors.hex2rgb("")  # Empty string


def test_edge_non_string_input():
    # Test non-string input
    with pytest.raises(TypeError):
        Colors.hex2rgb(123456)  # 2.27μs -> 1.16μs (96.2% faster)
    with pytest.raises(TypeError):
        Colors.hex2rgb(None)  # 1.13μs -> 690ns (64.2% faster)
    with pytest.raises(TypeError):
        Colors.hex2rgb([255, 255, 255])  # 1.18μs -> 796ns (48.0% faster)


def test_edge_invalid_characters():
    # Test hex with invalid characters
    with pytest.raises(ValueError):
        Colors.hex2rgb("#GGGGGG")  # 3.38μs -> 2.66μs (27.0% faster)
    with pytest.raises(ValueError):
        Colors.hex2rgb("12X456")  # 1.57μs -> 1.06μs (47.5% faster)
    with pytest.raises(ValueError):
        Colors.hex2rgb("#!@#$%^")  # 1.37μs -> 967ns (42.0% faster)


def test_edge_only_hash():
    # Test only hash character
    with pytest.raises(ValueError):
        Colors.hex2rgb("#")  # 2.99μs -> 2.13μs (40.3% faster)


def test_edge_empty_string():
    # Empty string
    with pytest.raises(ValueError):
        Colors.hex2rgb("")  # 2.86μs -> 2.01μs (42.6% faster)


def test_edge_spaces_only():
    # String of spaces only
    with pytest.raises(ValueError):
        Colors.hex2rgb("      ")  # 2.93μs -> 2.14μs (36.8% faster)


def test_edge_unusual_but_valid_hex():
    # Test valid but unusual hex (all zeros, all Fs, alternating)
    codeflash_output = Colors.hex2rgb("#000000")  # 2.05μs -> 1.21μs (69.9% faster)
    codeflash_output = Colors.hex2rgb("#FFFFFF")  # 1.14μs -> 593ns (92.1% faster)
    codeflash_output = Colors.hex2rgb("#F0F0F0")  # 805ns -> 457ns (76.1% faster)
    codeflash_output = Colors.hex2rgb("0F0F0F")  # 889ns -> 433ns (105% faster)


def test_edge_lowercase_hex():
    # Lowercase hex
    codeflash_output = Colors.hex2rgb("#abcdef")  # 1.69μs -> 935ns (80.2% faster)
    codeflash_output = Colors.hex2rgb("abcdef")  # 1.11μs -> 615ns (80.7% faster)


def test_edge_uppercase_hex():
    # Uppercase hex
    codeflash_output = Colors.hex2rgb("#ABCDEF")  # 1.68μs -> 827ns (103% faster)
    codeflash_output = Colors.hex2rgb("ABCDEF")  # 1.02μs -> 554ns (84.1% faster)


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


def test_large_scale_random_hex():
    # Test conversion of many random valid hex strings
    import random

    for _ in range(500):
        hex_str = "#{:06x}".format(random.randint(0, 0xFFFFFF))
        codeflash_output = Colors.hex2rgb(hex_str)
        rgb = codeflash_output  # 357μs -> 185μs (92.9% faster)
        for v in rgb:
            pass


def test_large_scale_non_string_inputs():
    # Test many non-string inputs to ensure all raise TypeError
    invalid_inputs = [None, 123456, 12.34, [], {}, (1, 2, 3), True, False]
    for inp in invalid_inputs:
        with pytest.raises(TypeError):
            Colors.hex2rgb(inp)


def test_mutation_wrong_order():
    # If the order of RGB is changed, this test will fail
    codeflash_output = Colors.hex2rgb("#123456")  # 2.43μs -> 1.26μs (93.3% faster)


def test_mutation_wrong_parsing():
    # If parsing is not done by pairs, this test will fail
    codeflash_output = Colors.hex2rgb("#AABBCC")  # 2.11μs -> 1.02μs (106% faster)


def test_mutation_wrong_type():
    # If function returns a list instead of tuple, this will fail
    codeflash_output = type(Colors.hex2rgb("#112233"))  # 1.81μs -> 922ns (96.5% faster)


def test_mutation_wrong_value():
    # If function returns values outside 0-255, this will fail
    codeflash_output = Colors.hex2rgb("#010203")
    rgb = codeflash_output  # 1.90μs -> 984ns (93.1% faster)
    for v in rgb:
        pass


def test_mutation_wrong_case_handling():
    # If function does not handle case-insensitive hex, this will fail
    codeflash_output = Colors.hex2rgb("#aBcDeF")  # 1.77μs -> 847ns (109% 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-Colors.hex2rgb-mi8eaffq and push.