⚡️ Speed up function get_class_names_from_environment_file by 20%

[codeflash-ai]

📄 20% (0.20x) speedup for get_class_names_from_environment_file in inference/core/models/roboflow.py

⏱️ Runtime : 474 microseconds → 396 microseconds (best of 53 runs)

📝 Explanation and details

The optimized code achieves a 19% speedup through two key micro-optimizations:

1. Eliminated repeated dictionary lookups: The original code accessed environment["CLASS_MAP"] multiple times - once in len() and once per iteration in the loop. The optimized version stores this in a local variable class_map, reducing dictionary access overhead.

2. Replaced loop+append with list comprehension: List comprehensions are faster than equivalent for-loops with append() calls because they're implemented in C and avoid the overhead of repeated method calls and list resizing.

Performance characteristics based on test results:

• Small datasets (1-10 classes): Minimal improvement or slight regression (~2-10% slower) due to the overhead of creating additional variables
• Large datasets (1000+ classes): Significant improvements (~23-25% faster) where the optimizations compound over many iterations
• Empty datasets: Slight regression (~10% slower) as the variable assignment overhead isn't offset by loop savings

The optimization particularly shines for production scenarios with many class labels, where the repeated dictionary lookups and append operations become bottlenecks. For small class maps, the original code may be marginally faster due to fewer operations, but the difference is negligible in practice.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 14 Passed
🌀 Generated Regression Tests	✅ 23 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_class_names_from_environment_file	4.38μs	4.43μs	-1.17%⚠️
inference/unit_tests/core/models/test_roboflow.py::test_get_class_names_from_environment_file_when_procedure_should_fail	3.92μs	4.19μs	-6.30%⚠️

🌀 Generated Regression Tests and Runtime

from typing import List, Optional

# imports
import pytest
from inference.core.models.roboflow import \
    get_class_names_from_environment_file


class ModelArtefactError(Exception):
    pass
from inference.core.models.roboflow import \
    get_class_names_from_environment_file

# unit tests

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

def test_basic_valid_environment_sequential_indices():
    # CLASS_MAP uses string indices, sequentially, starting from "0"
    env = {"CLASS_MAP": {"0": "cat", "1": "dog", "2": "mouse"}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 2.89μs -> 3.18μs (9.15% slower)

def test_basic_valid_environment_single_class():
    # Only one class present
    env = {"CLASS_MAP": {"0": "car"}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 2.24μs -> 2.36μs (5.25% slower)

def test_basic_valid_environment_empty_class_map():
    # CLASS_MAP is present but empty
    env = {"CLASS_MAP": {}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 1.68μs -> 1.82μs (7.73% slower)

def test_basic_valid_environment_non_sequential_indices():
    # CLASS_MAP keys are not sequential (should still follow 0..N-1 order)
    env = {"CLASS_MAP": {"0": "apple", "2": "banana", "1": "pear"}}
    # Should return ["apple", "pear", "banana"] because order is 0,1,2
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 2.52μs -> 2.54μs (0.394% slower)

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



def test_class_map_keys_are_not_strings():
    # CLASS_MAP keys are integers, but function expects strings
    env = {"CLASS_MAP": {0: "cat", 1: "dog", 2: "mouse"}}
    # Will raise KeyError because str(i) is not in keys
    with pytest.raises(KeyError):
        get_class_names_from_environment_file(env) # 2.98μs -> 3.50μs (14.9% slower)

def test_class_map_missing_some_indices():
    # CLASS_MAP is missing some expected indices (e.g. "1" missing)
    env = {"CLASS_MAP": {"0": "cat", "2": "dog"}}
    # Should raise KeyError when trying to access "1"
    with pytest.raises(KeyError):
        get_class_names_from_environment_file(env) # 2.81μs -> 2.86μs (1.89% slower)


def test_class_map_with_non_string_values():
    # CLASS_MAP values are not strings
    env = {"CLASS_MAP": {"0": 123, "1": None, "2": ["a", "b"]}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 2.97μs -> 3.33μs (10.6% slower)

def test_class_map_with_duplicate_class_names():
    # CLASS_MAP contains duplicate class names
    env = {"CLASS_MAP": {"0": "cat", "1": "cat", "2": "dog"}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 2.38μs -> 2.37μs (0.421% faster)

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

def test_large_scale_1000_classes():
    # Large CLASS_MAP with 1000 classes
    env = {"CLASS_MAP": {str(i): f"class_{i}" for i in range(1000)}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 93.1μs -> 75.5μs (23.4% faster)

def test_large_scale_missing_one_index():
    # Large CLASS_MAP with one missing index
    env = {"CLASS_MAP": {str(i): f"class_{i}" for i in range(1000) if i != 500}}
    with pytest.raises(KeyError):
        get_class_names_from_environment_file(env) # 46.7μs -> 38.5μs (21.4% faster)

def test_large_scale_non_sequential_keys():
    # Large CLASS_MAP with keys shuffled (should still use str(i) in order)
    import random
    keys = [str(i) for i in range(1000)]
    random.shuffle(keys)
    env = {"CLASS_MAP": {k: f"class_{k}" for k in keys}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 93.2μs -> 75.7μs (23.1% faster)



#------------------------------------------------
from typing import List, Optional

# imports
import pytest
from inference.core.models.roboflow import \
    get_class_names_from_environment_file

# --- Function and dependencies to test (copied from the prompt) ---

class ModelArtefactError(Exception):
    pass
from inference.core.models.roboflow import \
    get_class_names_from_environment_file

# --- Unit Tests ---

# 1. Basic Test Cases

def test_basic_single_class():
    # Test with a single class in CLASS_MAP
    env = {"CLASS_MAP": {"0": "cat"}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 2.32μs -> 2.43μs (4.77% slower)

def test_basic_multiple_classes():
    # Test with multiple classes in CLASS_MAP
    env = {"CLASS_MAP": {"0": "cat", "1": "dog", "2": "bird"}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 2.32μs -> 2.44μs (4.84% slower)

def test_basic_class_names_are_strings():
    # Test that class names can be any string
    env = {"CLASS_MAP": {"0": "foo", "1": "bar"}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 2.24μs -> 2.31μs (2.91% slower)

def test_basic_empty_class_map():
    # Test with empty CLASS_MAP
    env = {"CLASS_MAP": {}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 1.61μs -> 1.80μs (10.6% slower)

# 2. Edge Test Cases







def test_class_map_has_extra_keys():
    # Test when CLASS_MAP has extra keys not in sequence
    env = {"CLASS_MAP": {"0": "cat", "1": "dog", "extra": "horse"}}
    # Should ignore extra keys (since only str(i) for i in range(len(keys)))
    # len(keys) == 3, so i=0,1,2; str(0), str(1), str(2)
    # Only "0" and "1" exist, "2" does not, should raise KeyError
    with pytest.raises(KeyError):
        get_class_names_from_environment_file(env) # 3.59μs -> 3.86μs (6.92% slower)

def test_class_map_with_non_string_values():
    # Test when CLASS_MAP has non-string values
    env = {"CLASS_MAP": {"0": 123, "1": None, "2": ["a", "b"]}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 2.51μs -> 2.61μs (4.06% slower)

def test_class_map_with_large_index_strings():
    # Test with large index strings
    env = {"CLASS_MAP": {str(i): f"class_{i}" for i in range(10)}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 2.90μs -> 2.73μs (6.04% faster)

# 3. Large Scale Test Cases

def test_large_scale_1000_classes():
    # Test with 1000 classes
    env = {"CLASS_MAP": {str(i): f"class_{i}" for i in range(1000)}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 92.8μs -> 73.9μs (25.5% faster)

def test_large_scale_missing_some_indices():
    # Test with 1000 classes, but missing some indices
    env = {"CLASS_MAP": {str(i): f"class_{i}" for i in range(0, 1000, 2)}}  # Only even indices
    # For i in range(500): str(i) for i in range(500) -- only str(0), str(1), ..., str(499)
    # But only even indices exist, so for odd i, KeyError
    # Let's see what happens
    with pytest.raises(KeyError):
        get_class_names_from_environment_file(env) # 2.66μs -> 2.78μs (4.21% slower)


def test_large_scale_non_string_values():
    # Test with 1000 classes, but values are numbers
    env = {"CLASS_MAP": {str(i): i for i in range(1000)}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 95.6μs -> 76.6μs (24.8% faster)

def test_large_scale_empty_class_map():
    # Test with empty CLASS_MAP in large scale scenario
    env = {"CLASS_MAP": {}}
    codeflash_output = get_class_names_from_environment_file(env); result = codeflash_output # 1.69μs -> 1.89μs (10.2% slower)
# 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_class_names_from_environment_file-mh9ify9e and push.