⚡️ Speed up function str_to_color by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for str_to_color in inference/core/workflows/core_steps/visualizations/common/utils.py

⏱️ Runtime : 4.52 milliseconds → 4.26 milliseconds (best of 34 runs)

📝 Explanation and details

The optimized code achieves a 6% speedup through three key optimizations:

1. Pre-computed Color Name Lookup
The biggest performance gain comes from eliminating repeated hasattr() and getattr() calls for color names. The original code performed expensive attribute reflection for each color name lookup:

• hasattr(sv.Color, color.upper()) - checks if attribute exists
• getattr(sv.Color, color.upper()) - retrieves the attribute
• color.upper() - converts string to uppercase

The optimized version pre-computes all valid color attributes once at module load time into _COLOR_NAME_MAP, then uses a simple dictionary lookup with color.lower(). This provides 790-846% faster performance for named colors according to the test results.

2. Optimized RGB/BGR Parsing
For RGB and BGR parsing, the optimization replaces map(int, color[4:-1].split(",")) with direct integer conversion of split values when exactly 3 values are present. This avoids creating a temporary map object and provides 2-3% faster performance for RGB/BGR colors.

3. Single String Operation
The color name lookup now calls .lower() only once and stores the result, rather than calling .upper() twice in the original code's hasattr/getattr pattern.

Impact on Hot Path Usage
Based on the function references, str_to_color is called in QR code generation for both fill_color and back_color parameters. While QR generation may not be in the critical rendering path, the optimization particularly benefits workloads with:

• Named colors: 8-9x faster lookup (common for standard colors like "WHITE", "BLACK")
• Batch processing: 1-2% improvement for RGB/BGR parsing when processing many colors
• Mixed color formats: The pre-computed lookup eliminates reflection overhead entirely

The optimization maintains full backward compatibility while providing consistent performance improvements across all color format types.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
workflows/unit_tests/core_steps/visualizations/test_str_to_color.py::test_str_to_color_with_bgr_color	3.36μs	2.81μs	19.4%✅
workflows/unit_tests/core_steps/visualizations/test_str_to_color.py::test_str_to_color_with_color_name	12.6μs	1.56μs	705%✅
workflows/unit_tests/core_steps/visualizations/test_str_to_color.py::test_str_to_color_with_hex_color	6.89μs	7.11μs	-3.01%⚠️
workflows/unit_tests/core_steps/visualizations/test_str_to_color.py::test_str_to_color_with_invalid_color	2.49μs	1.61μs	54.5%✅
workflows/unit_tests/core_steps/visualizations/test_str_to_color.py::test_str_to_color_with_rgb_color	2.67μs	2.50μs	6.73%✅

🌀 Generated Regression Tests and Runtime

import pytest
from inference.core.workflows.core_steps.visualizations.common.utils import str_to_color


# --- Dummy sv.Color class for testing, since we don't have 'supervision' package ---
# This is a minimal mock to allow the test to run and to enforce correct behavior.
class DummyColor:
    # Predefined colors as class attributes
    WHITE = "WHITE"
    BLACK = "BLACK"
    BLUE = "BLUE"
    RED = "RED"
    GREEN = "GREEN"
    # Add more as needed for tests

    def __init__(self, r, g, b):
        self.rgb = (r, g, b)

    @classmethod
    def from_hex(cls, hexstr):
        # Accepts "#RRGGBB" or "RRGGBB"
        s = hexstr.lstrip("#")
        if len(s) != 6:
            raise ValueError("Invalid hex color")
        r = int(s[0:2], 16)
        g = int(s[2:4], 16)
        b = int(s[4:6], 16)
        return cls(r, g, b)

    @classmethod
    def from_rgb_tuple(cls, tup):
        r, g, b = tup
        return cls(r, g, b)

    @classmethod
    def from_bgr_tuple(cls, tup):
        b, g, r = tup
        return cls(r, g, b)

    def __eq__(self, other):
        if isinstance(other, DummyColor):
            return self.rgb == other.rgb
        if isinstance(other, str):
            # Allow comparison to color names
            return self.__class__.__dict__.get(other, None) == self
        return False

    def __repr__(self):
        return f"DummyColor{self.rgb}"


# Dummy sv module with Color
class sv:
    Color = DummyColor


from inference.core.workflows.core_steps.visualizations.common.utils import str_to_color

# --- Unit Tests ---

# 1. Basic Test Cases


@pytest.mark.parametrize(
    "input_str,expected",
    [
        # Hex colors
        ("#FFFFFF", DummyColor(255, 255, 255)),  # white
        ("#000000", DummyColor(0, 0, 0)),  # black
        ("#123456", DummyColor(18, 52, 86)),  # arbitrary hex
        # RGB colors
        ("rgb(255,0,0)", DummyColor(255, 0, 0)),  # red
        ("rgb(0,255,0)", DummyColor(0, 255, 0)),  # green
        ("rgb(0,0,255)", DummyColor(0, 0, 255)),  # blue
        ("rgb(12,34,56)", DummyColor(12, 34, 56)),  # arbitrary
        # BGR colors
        ("bgr(255,0,0)", DummyColor(0, 0, 255)),  # blue (b=255, g=0, r=0)
        ("bgr(0,255,0)", DummyColor(0, 255, 0)),  # green
        ("bgr(0,0,255)", DummyColor(255, 0, 0)),  # red
        ("bgr(12,34,56)", DummyColor(56, 34, 12)),  # arbitrary
        # Named colors
        ("WHITE", DummyColor.WHITE),
        ("black", DummyColor.BLACK),
        ("Blue", DummyColor.BLUE),
        ("ReD", DummyColor.RED),
    ],
)
def test_str_to_color_basic(input_str, expected):
    # Test basic valid inputs for all supported formats and color names
    codeflash_output = str_to_color(input_str)
    result = codeflash_output  # 84.8μs -> 46.4μs (82.9% faster)
    # For named colors, the result is a string attribute, otherwise DummyColor
    if isinstance(expected, DummyColor):
        pass
    else:
        pass


# 2. Edge Test Cases


@pytest.mark.parametrize(
    "input_str,expected_exception",
    [
        # Invalid hex: wrong length
        ("#FFF", ValueError),
        ("#12345", ValueError),
        ("#1234567", ValueError),
        # Invalid hex: invalid characters
        ("#GGHHII", ValueError),
        # Invalid rgb: missing values
        ("rgb(255,0)", ValueError),
        ("rgb(255)", ValueError),
        ("rgb()", ValueError),
        # Invalid rgb: out of range values (should still parse, but let's check)
        ("rgb(256,0,0)", DummyColor(256, 0, 0)),  # Accepts 256 as int
        # Invalid rgb: non-integer
        ("rgb(a,b,c)", ValueError),
        # Invalid bgr: missing values
        ("bgr(255,0)", ValueError),
        ("bgr(255)", ValueError),
        ("bgr()", ValueError),
        # Invalid bgr: non-integer
        ("bgr(a,b,c)", ValueError),
        # Invalid color name
        ("notacolor", ValueError),
        ("", ValueError),
        ("purple", ValueError),  # Not defined in DummyColor
        # Named color: case insensitivity
        ("wHiTe", DummyColor.WHITE),
        ("BlAcK", DummyColor.BLACK),
    ],
)
def test_str_to_color_edge(input_str, expected_exception):
    # Test edge cases: malformed input, missing values, bad color names, case insensitivity
    if isinstance(expected_exception, type) and issubclass(
        expected_exception, Exception
    ):
        with pytest.raises(expected_exception):
            str_to_color(input_str)  # 26.2μs -> 6.38μs (311% faster)
    else:
        codeflash_output = str_to_color(input_str)
        result = codeflash_output


def test_str_to_color_hex_without_hash():
    # Test hex without leading '#'
    with pytest.raises(ValueError):
        str_to_color("123456")  # 2.36μs -> 1.50μs (57.3% faster)


def test_str_to_color_partial_match():
    # Test partial matches that look like valid formats but aren't
    with pytest.raises(ValueError):
        str_to_color("rgb255,0,0")  # 5.09μs -> 4.56μs (11.7% faster)
    with pytest.raises(ValueError):
        str_to_color("bgr255,0,0")  # 1.87μs -> 1.89μs (0.953% slower)


def test_str_to_color_case_sensitive_prefix():
    # Test that prefixes are case sensitive
    with pytest.raises(ValueError):
        str_to_color("RGB(255,0,0)")  # 2.90μs -> 1.61μs (79.9% faster)
    with pytest.raises(ValueError):
        str_to_color("BGR(0,0,255)")  # 1.34μs -> 766ns (74.8% faster)


# 3. Large Scale Test Cases


def test_str_to_color_many_hex_colors():
    # Test a large number of unique hex colors
    for i in range(0, 1000, 13):  # step to keep under 1000 elements
        hexstr = "#{:06X}".format(i)
        codeflash_output = str_to_color(hexstr)
        result = codeflash_output  # 130μs -> 130μs (0.050% slower)
        r = (i >> 16) & 0xFF
        g = (i >> 8) & 0xFF
        b = i & 0xFF


def test_str_to_color_many_rgb_colors():
    # Test a large number of unique rgb colors
    for i in range(0, 1000, 17):
        r = (i * 3) % 256
        g = (i * 5) % 256
        b = (i * 7) % 256
        rgb_str = f"rgb({r},{g},{b})"
        codeflash_output = str_to_color(rgb_str)
        result = codeflash_output  # 60.2μs -> 58.8μs (2.33% faster)


def test_str_to_color_many_bgr_colors():
    # Test a large number of unique bgr colors
    for i in range(0, 1000, 19):
        b = (i * 2) % 256
        g = (i * 4) % 256
        r = (i * 6) % 256
        bgr_str = f"bgr({b},{g},{r})"
        codeflash_output = str_to_color(bgr_str)
        result = codeflash_output  # 56.2μs -> 54.8μs (2.59% faster)


def test_str_to_color_large_batch_named_colors():
    # Test all predefined named colors in DummyColor
    color_names = [
        attr for attr in dir(DummyColor) if not attr.startswith("__") and attr.isupper()
    ]
    for name in color_names:
        codeflash_output = str_to_color(name)
        result = codeflash_output  # 25.7μs -> 2.89μs (790% faster)
        # Also test lower/upper/mixed case
        codeflash_output = str_to_color(name.lower())
        result2 = codeflash_output  # 18.0μs -> 1.90μs (846% faster)
        codeflash_output = str_to_color(name.capitalize())
        result3 = codeflash_output


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

from types import SimpleNamespace

# imports
import pytest  # used for our unit tests
from inference.core.workflows.core_steps.visualizations.common.utils import str_to_color


# --- Minimal mock for supervision.Color to allow tests to run without supervision installed ---
# This is a minimal drop-in replacement for sv.Color for testing purposes only.
class MockColor:
    # Some standard color names as class attributes
    RED = "RED"
    GREEN = "GREEN"
    BLUE = "BLUE"
    WHITE = "WHITE"
    BLACK = "BLACK"
    YELLOW = "YELLOW"
    CYAN = "CYAN"
    MAGENTA = "MAGENTA"
    GRAY = "GRAY"

    def __init__(self, r, g, b):
        self.rgb = (r, g, b)

    @classmethod
    def from_hex(cls, hex_str):
        hex_str = hex_str.lstrip("#")
        if len(hex_str) != 6:
            raise ValueError("Invalid hex color")
        r = int(hex_str[0:2], 16)
        g = int(hex_str[2:4], 16)
        b = int(hex_str[4:6], 16)
        return cls(r, g, b)

    @classmethod
    def from_rgb_tuple(cls, rgb_tuple):
        r, g, b = rgb_tuple
        return cls(r, g, b)

    @classmethod
    def from_bgr_tuple(cls, bgr_tuple):
        b, g, r = bgr_tuple
        return cls(r, g, b)

    def __eq__(self, other):
        if isinstance(other, MockColor):
            return self.rgb == other.rgb
        if isinstance(other, str):
            # Allow comparison to color names
            return False
        return False

    def __repr__(self):
        return f"MockColor(rgb={self.rgb})"


# Patch sv.Color for test
sv = SimpleNamespace(Color=MockColor)
from inference.core.workflows.core_steps.visualizations.common.utils import str_to_color

# unit tests

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


@pytest.mark.parametrize(
    "input_str,expected",
    [
        # Hex colors
        ("#FF0000", MockColor(255, 0, 0)),  # Red
        ("#00FF00", MockColor(0, 255, 0)),  # Green
        ("#0000FF", MockColor(0, 0, 255)),  # Blue
        ("#ffffff", MockColor(255, 255, 255)),  # White, lower case
        ("#000000", MockColor(0, 0, 0)),  # Black
        # RGB colors
        ("rgb(255,0,0)", MockColor(255, 0, 0)),  # Red
        ("rgb(0,255,0)", MockColor(0, 255, 0)),  # Green
        ("rgb(0,0,255)", MockColor(0, 0, 255)),  # Blue
        ("rgb(255,255,255)", MockColor(255, 255, 255)),  # White
        ("rgb(0,0,0)", MockColor(0, 0, 0)),  # Black
        # BGR colors
        ("bgr(0,0,255)", MockColor(255, 0, 0)),  # Red (BGR)
        ("bgr(0,255,0)", MockColor(0, 255, 0)),  # Green (BGR)
        ("bgr(255,0,0)", MockColor(0, 0, 255)),  # Blue (BGR)
        ("bgr(255,255,255)", MockColor(255, 255, 255)),  # White (BGR)
        ("bgr(0,0,0)", MockColor(0, 0, 0)),  # Black (BGR)
        # Color names (case-insensitive)
        ("RED", "RED"),
        ("green", "GREEN"),
        ("Blue", "BLUE"),
        ("white", "WHITE"),
        ("BLACK", "BLACK"),
        ("Yellow", "YELLOW"),
        ("CYAN", "CYAN"),
        ("magenta", "MAGENTA"),
        ("gray", "GRAY"),
    ],
)
def test_str_to_color_basic(input_str, expected):
    """Test basic valid color string inputs."""
    codeflash_output = str_to_color(input_str)
    result = codeflash_output  # 122μs -> 65.8μs (85.6% faster)
    if isinstance(expected, MockColor):
        pass
    else:
        pass


# -------------------- EDGE TEST CASES --------------------


@pytest.mark.parametrize(
    "input_str,expected_exception,expected_msg_part",
    [
        # Invalid hex: too short
        ("#FFF", ValueError, "Invalid hex color"),
        # Invalid hex: too long
        ("#1234567", ValueError, "Invalid hex color"),
        # Invalid hex: non-hex characters
        ("#GGHHII", ValueError, "invalid literal"),
        # Invalid RGB: missing values
        ("rgb(255,0)", ValueError, "not enough values"),
        # Invalid RGB: too many values
        ("rgb(255,0,0,0)", ValueError, "too many values"),
        # Invalid RGB: non-int values
        ("rgb(a,b,c)", ValueError, "invalid literal"),
        # Invalid BGR: missing values
        ("bgr(255,0)", ValueError, "not enough values"),
        # Invalid BGR: too many values
        ("bgr(255,0,0,0)", ValueError, "too many values"),
        # Invalid BGR: non-int values
        ("bgr(a,b,c)", ValueError, "invalid literal"),
        # Unknown color name
        ("notacolor", ValueError, "Invalid text color"),
        # Empty string
        ("", ValueError, "Invalid text color"),
        # Only hash
        ("#", ValueError, "Invalid hex color"),
        # Only rgb prefix
        ("rgb()", ValueError, "not enough values"),
        # Only bgr prefix
        ("bgr()", ValueError, "not enough values"),
        # Color name with trailing space
        ("RED ", ValueError, "Invalid text color"),
        # Color name with leading space
        (" BLUE", ValueError, "Invalid text color"),
        # Hex with missing hash
        ("FF0000", ValueError, "Invalid text color"),
        # RGB with missing parenthesis
        ("rgb255,0,0", ValueError, "Invalid text color"),
        # BGR with missing parenthesis
        ("bgr255,0,0", ValueError, "Invalid text color"),
    ],
)
def test_str_to_color_edge_cases(input_str, expected_exception, expected_msg_part):
    """Test edge and invalid cases for str_to_color."""
    with pytest.raises(expected_exception) as excinfo:
        str_to_color(input_str)  # 63.2μs -> 57.0μs (10.8% faster)


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


def test_str_to_color_large_hex_batch():
    """Test str_to_color with a large batch of unique hex colors."""
    # Generate 1000 hex colors, from #000000 to #03E703 (step 3)
    for i in range(0, 1000):
        r = (i * 3) % 256
        g = (i * 7) % 256
        b = (i * 11) % 256
        hex_str = f"#{r:02X}{g:02X}{b:02X}"
        codeflash_output = str_to_color(hex_str)
        result = codeflash_output  # 1.56ms -> 1.56ms (0.073% faster)


def test_str_to_color_large_rgb_batch():
    """Test str_to_color with a large batch of unique rgb colors."""
    for i in range(0, 1000):
        r = (i * 5) % 256
        g = (i * 13) % 256
        b = (i * 17) % 256
        rgb_str = f"rgb({r},{g},{b})"
        codeflash_output = str_to_color(rgb_str)
        result = codeflash_output  # 911μs -> 898μs (1.49% faster)


def test_str_to_color_large_bgr_batch():
    """Test str_to_color with a large batch of unique bgr colors."""
    for i in range(0, 1000):
        b = (i * 2) % 256
        g = (i * 3) % 256
        r = (i * 4) % 256
        bgr_str = f"bgr({b},{g},{r})"
        codeflash_output = str_to_color(bgr_str)
        result = codeflash_output  # 957μs -> 935μs (2.34% faster)


def test_str_to_color_all_color_names():
    """Test that all defined color names are accepted (case-insensitive)."""
    color_names = [
        "RED",
        "GREEN",
        "BLUE",
        "WHITE",
        "BLACK",
        "YELLOW",
        "CYAN",
        "MAGENTA",
        "GRAY",
    ]
    for name in color_names:
        # Try all lower, upper, and title case
        for variant in [name.lower(), name.upper(), name.title()]:
            codeflash_output = str_to_color(variant)
            result = codeflash_output


def test_str_to_color_performance_large_mixed():
    """Test a large mixed batch of valid and invalid color strings."""
    valid_hex = [f"#{i:06X}" for i in range(100)]
    valid_rgb = [f"rgb({i%256},{(i*2)%256},{(i*3)%256})" for i in range(100)]
    valid_bgr = [f"bgr({i%256},{(i*2)%256},{(i*3)%256})" for i in range(100)]
    valid_names = [
        "red",
        "green",
        "blue",
        "white",
        "black",
        "yellow",
        "cyan",
        "magenta",
        "gray",
    ]

    invalids = ["#ZZZZZZ", "rgb(,,)", "bgr(256,256,256)", "notacolor", "rgb()", "bgr()"]

    # Mix them together
    mixed = valid_hex + valid_rgb + valid_bgr + valid_names + invalids
    results = []
    for s in mixed:
        try:
            codeflash_output = str_to_color(s)
            result = codeflash_output
            results.append((s, True))
        except Exception:
            results.append((s, False))
    # Check that all valid entries succeeded and all invalid entries failed
    for s, ok in results:
        if s in invalids:
            pass
        else:
            pass


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

⏪ Replay Tests and Runtime

To edit these changes git checkout codeflash/optimize-str_to_color-miqjntrk and push.