⚡️ Speed up function get_color_mapping_from_environment by 12%

[codeflash-ai]

📄 12% (0.12x) speedup for get_color_mapping_from_environment in inference/core/models/roboflow.py

⏱️ Runtime : 278 microseconds → 248 microseconds (best of 358 runs)

📝 Explanation and details

The optimized code achieves a 12% speedup by eliminating redundant function calls and reducing attribute lookups in hot paths.

Key optimizations:

1. Inlined environment validation: Instead of calling color_mapping_available_in_environment() separately, the validation logic is moved directly into the main function. This eliminates one function call overhead when environment colors are available (the common case in many test scenarios).

2. Reduced repeated attribute lookups: The original code accessed DEFAULT_COLOR_PALETTE and computed len(DEFAULT_COLOR_PALETTE) multiple times within the dictionary comprehension. The optimized version caches these values in local variables (palette and palette_len), avoiding repeated global lookups and length calculations.

3. Import optimization: Added explicit import of DEFAULT_COLOR_PALETTE to reduce module attribute resolution overhead.

Performance characteristics by test case:

• Environment with colors: 7-20% faster due to eliminated function call overhead
• Large-scale default palette generation: 10-19% faster due to cached palette length and reduced attribute lookups in the tight loop
• Edge cases: 1-10% faster from reduced overhead, though some very small cases show minimal regression due to slightly more upfront setup

The optimizations are most effective for scenarios with either valid environment colors (eliminating function call) or large class lists requiring default palette cycling (eliminating repeated length calculations in loops).

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
inference/unit_tests/core/models/test_roboflow.py::test_get_color_mapping_from_environment_when_color_mapping_in_environment	1.06μs	1.02μs	4.41%✅
inference/unit_tests/core/models/test_roboflow.py::test_get_color_mapping_from_environment_when_color_mapping_in_environment_as_json_string	2.51μs	2.37μs	5.96%✅
inference/unit_tests/core/models/test_roboflow.py::test_get_color_mapping_from_environment_when_color_mapping_not_in_environment	2.21μs	2.15μs	2.42%✅

🌀 Generated Regression Tests and Runtime

from typing import Dict, List, Optional

# imports
import pytest  # used for our unit tests
from inference.core.models.roboflow import get_color_mapping_from_environment

# function to test (copied from the provided code)
DEFAULT_COLOR_PALETTE = [
    "#4892EA",
    "#00EEC3",
    "#FE4EF0",
    "#F4004E",
    "#FA7200",
    "#EEEE17",
    "#90FF00",
    "#78C1D2",
    "#8C29FF",
]
from inference.core.models.roboflow import get_color_mapping_from_environment

# unit tests

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

def test_basic_default_palette_mapping():
    # Test with no environment, 3 classes
    class_names = ["cat", "dog", "mouse"]
    expected = {
        "cat": DEFAULT_COLOR_PALETTE[0],
        "dog": DEFAULT_COLOR_PALETTE[1],
        "mouse": DEFAULT_COLOR_PALETTE[2],
    }
    codeflash_output = get_color_mapping_from_environment(None, class_names); result = codeflash_output # 2.08μs -> 1.92μs (8.34% faster)

def test_basic_environment_colors_mapping():
    # Test with environment containing COLORS dict
    env = {"COLORS": {"cat": "#123456", "dog": "#654321"}}
    class_names = ["cat", "dog", "mouse"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 735ns -> 658ns (11.7% faster)

def test_basic_environment_colors_ignores_class_names():
    # COLORS mapping ignores class_names and returns entire COLORS dict
    env = {"COLORS": {"cat": "#123456", "dog": "#654321", "mouse": "#abcdef"}}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 734ns -> 670ns (9.55% faster)

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

def test_edge_empty_class_names():
    # Should return empty dict if class_names is empty
    codeflash_output = get_color_mapping_from_environment(None, []); result = codeflash_output # 1.19μs -> 1.27μs (6.99% slower)

def test_edge_environment_none():
    # Should fallback to default palette if environment is None
    class_names = ["bird"]
    expected = {"bird": DEFAULT_COLOR_PALETTE[0]}
    codeflash_output = get_color_mapping_from_environment(None, class_names); result = codeflash_output # 1.65μs -> 1.60μs (3.19% faster)

def test_edge_environment_missing_colors():
    # Should fallback to default palette if COLORS key missing
    env = {"NOT_COLORS": {"cat": "#111111"}}
    class_names = ["cat"]
    expected = {"cat": DEFAULT_COLOR_PALETTE[0]}
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.56μs -> 1.51μs (2.90% faster)

def test_edge_environment_colors_not_dict():
    # Should fallback to default palette if COLORS is not a dict
    env = {"COLORS": ["not", "a", "dict"]}
    class_names = ["cat"]
    expected = {"cat": DEFAULT_COLOR_PALETTE[0]}
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.69μs -> 1.74μs (2.99% slower)

def test_edge_environment_colors_is_empty_dict():
    # Should return empty dict if COLORS is empty dict
    env = {"COLORS": {}}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 748ns -> 715ns (4.62% faster)

def test_edge_environment_is_empty_dict():
    # Should fallback to default palette if environment is empty dict
    env = {}
    class_names = ["cat", "dog"]
    expected = {
        "cat": DEFAULT_COLOR_PALETTE[0],
        "dog": DEFAULT_COLOR_PALETTE[1],
    }
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.86μs -> 1.70μs (9.16% faster)

def test_edge_non_string_class_names():
    # Should handle non-string class names (e.g., int, tuple)
    class_names = [1, (2, 3), None]
    expected = {
        1: DEFAULT_COLOR_PALETTE[0],
        (2, 3): DEFAULT_COLOR_PALETTE[1],
        None: DEFAULT_COLOR_PALETTE[2],
    }
    codeflash_output = get_color_mapping_from_environment(None, class_names); result = codeflash_output # 1.95μs -> 1.81μs (7.27% faster)

def test_edge_colors_dict_with_extra_keys():
    # COLORS dict may contain keys not in class_names; should return full dict
    env = {"COLORS": {"cat": "#1", "dog": "#2", "extra": "#3"}}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 735ns -> 688ns (6.83% faster)

def test_edge_colors_dict_with_missing_keys():
    # COLORS dict may be missing some class_names; should return full dict
    env = {"COLORS": {"cat": "#1"}}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 735ns -> 683ns (7.61% faster)

def test_edge_colors_dict_with_non_string_keys():
    # COLORS dict may contain non-string keys
    env = {"COLORS": {1: "#1", None: "#2"}}
    class_names = [1, None]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 720ns -> 664ns (8.43% faster)

def test_edge_colors_dict_with_non_string_values():
    # COLORS dict may contain non-string values
    env = {"COLORS": {"cat": 123, "dog": None}}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 696ns -> 675ns (3.11% faster)

def test_edge_colors_dict_is_subclass_of_dict():
    # Should work if COLORS is a subclass of dict
    class MyDict(dict):
        pass
    env = {"COLORS": MyDict({"cat": "#abc"})}
    class_names = ["cat"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 742ns -> 722ns (2.77% faster)

def test_edge_colors_dict_is_not_exact_dict_type():
    # Should NOT work if COLORS is not a dict or subclass
    env = {"COLORS": set([("cat", "#abc")])}
    class_names = ["cat"]
    expected = {"cat": DEFAULT_COLOR_PALETTE[0]}
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.92μs -> 1.93μs (0.414% slower)

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

def test_large_scale_default_palette_cycle():
    # Test with 1000 class names, palette should cycle
    class_names = [f"class_{i}" for i in range(1000)]
    codeflash_output = get_color_mapping_from_environment(None, class_names); result = codeflash_output # 82.8μs -> 72.2μs (14.7% faster)
    for i, class_name in enumerate(class_names):
        expected_color = DEFAULT_COLOR_PALETTE[i % len(DEFAULT_COLOR_PALETTE)]

def test_large_scale_environment_colors():
    # Test with large COLORS dict in environment
    env = {"COLORS": {f"class_{i}": f"#{i:06x}" for i in range(1000)}}
    class_names = [f"class_{i}" for i in range(1000)]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 770ns -> 714ns (7.84% faster)

def test_large_scale_environment_colors_extra_keys():
    # COLORS dict has more keys than class_names; should return full dict
    env = {"COLORS": {f"class_{i}": f"#{i:06x}" for i in range(1000)}}
    class_names = [f"class_{i}" for i in range(500)]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 748ns -> 644ns (16.1% faster)

def test_large_scale_environment_colors_missing_keys():
    # COLORS dict has fewer keys than class_names; should return full dict
    env = {"COLORS": {f"class_{i}": f"#{i:06x}" for i in range(500)}}
    class_names = [f"class_{i}" for i in range(1000)]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 726ns -> 605ns (20.0% faster)

def test_large_scale_non_string_class_names():
    # Test with large number of non-string class names
    class_names = list(range(1000))
    codeflash_output = get_color_mapping_from_environment(None, class_names); result = codeflash_output # 57.6μs -> 48.4μs (19.1% faster)
    for i in range(1000):
        pass
# 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 inference.core.models.roboflow import get_color_mapping_from_environment

# function to test
DEFAULT_COLOR_PALETTE = [
    "#4892EA",
    "#00EEC3",
    "#FE4EF0",
    "#F4004E",
    "#FA7200",
    "#EEEE17",
    "#90FF00",
    "#78C1D2",
    "#8C29FF",
]
from inference.core.models.roboflow import get_color_mapping_from_environment

# unit tests

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

def test_basic_with_environment_colors():
    # Environment provides a color mapping
    env = {"COLORS": {"cat": "#123456", "dog": "#654321"}}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 830ns -> 756ns (9.79% faster)

def test_basic_without_environment_colors():
    # Environment is None, should use default palette
    env = None
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.95μs -> 1.83μs (6.23% faster)

def test_basic_environment_without_colors_key():
    # Environment exists but no COLORS key
    env = {"foo": "bar"}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.81μs -> 1.73μs (4.56% faster)

def test_basic_environment_colors_not_dict():
    # COLORS key is present but not a dict
    env = {"COLORS": ["not", "a", "dict"]}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.91μs -> 1.88μs (1.97% faster)

def test_basic_empty_class_names():
    # No class names provided
    env = None
    class_names = []
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.16μs -> 1.19μs (2.52% slower)

def test_basic_environment_colors_partial():
    # COLORS dict missing some class names
    env = {"COLORS": {"cat": "#123456"}}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 749ns -> 685ns (9.34% faster)

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

def test_edge_environment_is_empty_dict():
    # Environment is an empty dict
    env = {}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.91μs -> 1.82μs (4.88% faster)

def test_edge_colors_is_none():
    # COLORS is None
    env = {"COLORS": None}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.96μs -> 1.90μs (3.37% faster)

def test_edge_colors_is_int():
    # COLORS is an int
    env = {"COLORS": 123}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.91μs -> 1.89μs (1.49% faster)

def test_edge_colors_is_dict_with_non_string_keys():
    # COLORS dict has non-string keys
    env = {"COLORS": {1: "#123456", 2: "#654321"}}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 720ns -> 689ns (4.50% faster)

def test_edge_class_names_with_duplicates():
    # Duplicate class names
    env = None
    class_names = ["cat", "cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.87μs -> 1.81μs (2.87% faster)

def test_edge_class_names_are_non_strings():
    # Class names are ints
    env = None
    class_names = [1, 2, 3]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.92μs -> 1.74μs (10.2% faster)

def test_edge_environment_is_string():
    # Environment is a string
    env = "notadict"
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.70μs -> 1.70μs (0.235% faster)

def test_edge_colors_is_dict_with_extra_keys():
    # COLORS dict has more keys than class_names
    env = {"COLORS": {"cat": "#123456", "dog": "#654321", "bird": "#aaaaaa"}}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 751ns -> 709ns (5.92% faster)

def test_edge_colors_is_dict_with_no_keys():
    # COLORS dict is empty
    env = {"COLORS": {}}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 720ns -> 691ns (4.20% faster)

def test_edge_colors_is_dict_with_none_values():
    # COLORS dict has None values
    env = {"COLORS": {"cat": None, "dog": "#654321"}}
    class_names = ["cat", "dog"]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 704ns -> 677ns (3.99% faster)

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

def test_large_scale_many_classes_no_env():
    # Large number of class names, no environment
    env = None
    class_names = [f"class_{i}" for i in range(1000)]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 82.6μs -> 74.9μs (10.3% faster)
    for i in range(1000):
        pass

def test_large_scale_many_classes_with_env_colors():
    # Large COLORS dict in environment
    env = {"COLORS": {f"class_{i}": f"#{i:06x}" for i in range(1000)}}
    class_names = [f"class_{i}" for i in range(1000)]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 745ns -> 743ns (0.269% faster)
    for i in range(1000):
        pass

def test_large_scale_many_classes_with_env_colors_partial():
    # COLORS dict only provides some mappings
    env = {"COLORS": {f"class_{i}": f"#{i:06x}" for i in range(500)}}
    class_names = [f"class_{i}" for i in range(1000)]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 710ns -> 716ns (0.838% slower)
    for i in range(500):
        pass

def test_large_scale_empty_env_empty_class_names():
    # Both environment and class_names are empty
    env = None
    class_names = []
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 1.22μs -> 1.30μs (6.44% slower)

def test_large_scale_env_colors_with_extra_keys():
    # COLORS dict has more keys than class_names
    env = {"COLORS": {f"class_{i}": f"#{i:06x}" for i in range(1000)}}
    class_names = [f"class_{i}" for i in range(500)]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 781ns -> 686ns (13.8% faster)
    for i in range(1000):
        pass

def test_large_scale_env_colors_is_empty_dict():
    # COLORS dict is empty
    env = {"COLORS": {}}
    class_names = [f"class_{i}" for i in range(1000)]
    codeflash_output = get_color_mapping_from_environment(env, class_names); result = codeflash_output # 729ns -> 691ns (5.50% 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_color_mapping_from_environment-mh9ikt6f and push.