⚡️ Speed up method PixelateVisualizationBlockV1.getAnnotator by 42%

[codeflash-ai]

📄 42% (0.42x) speedup for PixelateVisualizationBlockV1.getAnnotator in inference/core/workflows/core_steps/visualizations/pixelate/v1.py

⏱️ Runtime : 2.49 milliseconds → 1.75 milliseconds (best of 224 runs)

📝 Explanation and details

The optimization achieves a 42% speedup by simplifying the cache key generation from "_".join(map(str, [pixel_size])) to str(pixel_size).

Key optimization:

• Eliminated unnecessary string operations: The original code created a single-element list [pixel_size], mapped str() over it, then joined with underscores - all to convert one value to string
• Direct string conversion: The optimized version uses str(pixel_size) directly, avoiding list creation, mapping, and joining operations

Why this improves performance:

• Removes 3 function calls (map, list creation, join) and replaces with 1 (str)
• Eliminates temporary list allocation and iterator overhead
• Reduces string concatenation operations

Test results show consistent improvements:

• Cache hits: 40-75% faster (e.g., repeated calls with same pixel_size)
• Cache misses: 30-46% faster (e.g., first call with new pixel_size)
• Large scale operations: 32-63% faster across 500+ unique values

The optimization is particularly effective for scenarios with frequent cache lookups and diverse pixel_size values, as shown in the annotated tests where both single calls and batch operations demonstrate significant performance gains.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from abc import ABC

# imports
import pytest
from inference.core.workflows.core_steps.visualizations.pixelate.v1 import \
    PixelateVisualizationBlockV1

# --- Minimal stub implementations for dependencies ---

class BaseAnnotator:
    def __init__(self, *args, **kwargs):
        pass

class PixelateAnnotator(BaseAnnotator):
    def __init__(self, pixel_size):
        super().__init__()
        self.pixel_size = pixel_size

class sv:
    class annotators:
        class base:
            BaseAnnotator = BaseAnnotator
    PixelateAnnotator = PixelateAnnotator

class VisualizationBlock:
    def __init__(self, *args, **kwargs):
        pass


class PredictionsVisualizationBlock(VisualizationBlock, ABC):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
from inference.core.workflows.core_steps.visualizations.pixelate.v1 import \
    PixelateVisualizationBlockV1

# --- Unit tests ---

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

def test_getAnnotator_returns_instance_of_PixelateAnnotator():
    # Test that getAnnotator returns a PixelateAnnotator instance for a normal pixel_size
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(8); annotator = codeflash_output # 2.25μs -> 1.61μs (39.6% faster)

def test_getAnnotator_returns_same_instance_for_same_pixel_size():
    # Test that getAnnotator returns the same instance for the same pixel_size (caching)
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(16); annotator1 = codeflash_output # 1.62μs -> 1.25μs (30.0% faster)
    codeflash_output = block.getAnnotator(16); annotator2 = codeflash_output # 630ns -> 447ns (40.9% faster)

def test_getAnnotator_returns_different_instances_for_different_pixel_sizes():
    # Test that getAnnotator returns different instances for different pixel_sizes
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(4); annotator1 = codeflash_output # 1.73μs -> 1.31μs (32.1% faster)
    codeflash_output = block.getAnnotator(8); annotator2 = codeflash_output # 862ns -> 667ns (29.2% faster)

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

def test_getAnnotator_with_pixel_size_zero():
    # Edge: pixel_size = 0 (possibly invalid, but function should handle it)
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(0); annotator = codeflash_output # 1.64μs -> 1.26μs (30.2% faster)

def test_getAnnotator_with_negative_pixel_size():
    # Edge: pixel_size = -5 (negative value)
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(-5); annotator = codeflash_output # 1.74μs -> 1.28μs (35.5% faster)

def test_getAnnotator_with_large_pixel_size():
    # Edge: pixel_size = very large value
    block = PixelateVisualizationBlockV1()
    large_pixel_size = 10**6
    codeflash_output = block.getAnnotator(large_pixel_size); annotator = codeflash_output # 1.74μs -> 1.34μs (30.2% faster)

def test_getAnnotator_with_non_integer_pixel_size():
    # Edge: pixel_size = float (should be coerced to string in key)
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(3.5); annotator = codeflash_output # 3.09μs -> 2.59μs (19.5% faster)
    # Should cache separately from int version
    codeflash_output = block.getAnnotator(3); annotator2 = codeflash_output # 967ns -> 756ns (27.9% faster)

def test_getAnnotator_with_string_pixel_size():
    # Edge: pixel_size = string (should be accepted as key, passed to PixelateAnnotator)
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator("10"); annotator = codeflash_output # 1.56μs -> 1.11μs (40.0% faster)

def test_getAnnotator_cache_is_per_instance():
    # Edge: Cache should not be shared between instances
    block1 = PixelateVisualizationBlockV1()
    block2 = PixelateVisualizationBlockV1()
    codeflash_output = block1.getAnnotator(5); annotator1 = codeflash_output # 1.62μs -> 1.23μs (31.9% faster)
    codeflash_output = block2.getAnnotator(5); annotator2 = codeflash_output # 814ns -> 654ns (24.5% faster)

def test_getAnnotator_cache_key_is_stringified():
    # Edge: pixel_size = tuple (should be stringified in key)
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator((2, 3)); annotator = codeflash_output # 2.67μs -> 2.44μs (9.36% faster)

def test_getAnnotator_cache_key_collision():
    # Edge: pixel_size = "1_2" and pixel_size = (1,2) should not collide
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator("1_2"); annotator_str = codeflash_output # 1.59μs -> 1.16μs (36.7% faster)
    codeflash_output = block.getAnnotator((1, 2)); annotator_tuple = codeflash_output # 1.50μs -> 1.40μs (7.27% faster)

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

def test_getAnnotator_many_unique_pixel_sizes():
    # Large scale: Call with many unique pixel_sizes, ensure all are cached and correct
    block = PixelateVisualizationBlockV1()
    num_sizes = 500
    annotators = []
    for i in range(num_sizes):
        codeflash_output = block.getAnnotator(i); annotator = codeflash_output # 284μs -> 215μs (32.0% faster)
        annotators.append(annotator)

def test_getAnnotator_cache_memory_efficiency():
    # Large scale: Ensure cache does not grow on repeated calls with same pixel_size
    block = PixelateVisualizationBlockV1()
    for i in range(100):
        for _ in range(10):
            codeflash_output = block.getAnnotator(i); a = codeflash_output

def test_getAnnotator_performance_with_large_number_of_calls():
    # Large scale: Performance test with many calls (not exceeding 1000 unique)
    block = PixelateVisualizationBlockV1()
    for i in range(999):
        codeflash_output = block.getAnnotator(i); a = codeflash_output # 568μs -> 428μs (32.7% faster)
    # Now repeat all calls to ensure cache is used
    for i in range(999):
        codeflash_output = block.getAnnotator(i); a = codeflash_output # 368μs -> 225μs (63.3% faster)

# ----------- Determinism and Consistency -----------

def test_getAnnotator_determinism():
    # Calling getAnnotator repeatedly with the same input should always return the same object
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(42); a1 = codeflash_output # 2.44μs -> 1.66μs (46.7% faster)
    codeflash_output = block.getAnnotator(42); a2 = codeflash_output # 663ns -> 440ns (50.7% faster)
    codeflash_output = block.getAnnotator(42); a3 = codeflash_output # 385ns -> 220ns (75.0% faster)

def test_getAnnotator_cache_isolation_between_instances():
    # Ensure that different PixelateVisualizationBlockV1 instances do not share cache
    blockA = PixelateVisualizationBlockV1()
    blockB = PixelateVisualizationBlockV1()
    codeflash_output = blockA.getAnnotator(7); aA = codeflash_output # 1.74μs -> 1.26μs (37.8% faster)
    codeflash_output = blockB.getAnnotator(7); aB = codeflash_output # 773ns -> 599ns (29.0% faster)
    # Changing one cache doesn't affect the other
    blockA.getAnnotator(8) # 726ns -> 534ns (36.0% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from abc import ABC

# imports
import pytest
from inference.core.workflows.core_steps.visualizations.pixelate.v1 import \
    PixelateVisualizationBlockV1


# Mocks for external dependencies (since we cannot import supervision or its annotators)
class MockBaseAnnotator:
    def __init__(self, pixel_size):
        self.pixel_size = pixel_size

class MockPixelateAnnotator(MockBaseAnnotator):
    pass

# Minimal stub for VisualizationBlock (since it's not provided)
class VisualizationBlock:
    def __init__(self, *args, **kwargs):
        pass

class PredictionsVisualizationBlock(VisualizationBlock, ABC):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
from inference.core.workflows.core_steps.visualizations.pixelate.v1 import \
    PixelateVisualizationBlockV1

# -------------------- UNIT TESTS --------------------

# 1. BASIC TEST CASES

def test_getAnnotator_returns_instance():
    """Test that getAnnotator returns an annotator instance for a given pixel_size."""
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(10); annotator = codeflash_output # 2.41μs -> 1.40μs (71.6% faster)

def test_getAnnotator_caching_mechanism():
    """Test that getAnnotator returns the same instance for the same pixel_size (caching)."""
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(5); a1 = codeflash_output # 1.77μs -> 1.27μs (39.0% faster)
    codeflash_output = block.getAnnotator(5); a2 = codeflash_output # 692ns -> 476ns (45.4% faster)

def test_getAnnotator_different_instances_for_different_pixel_sizes():
    """Test that getAnnotator returns different instances for different pixel_sizes."""
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(5); a1 = codeflash_output # 1.70μs -> 1.23μs (37.9% faster)
    codeflash_output = block.getAnnotator(6); a2 = codeflash_output # 954ns -> 706ns (35.1% faster)

def test_getAnnotator_cache_key_string_conversion():
    """Test that pixel_size is correctly converted to string for cache key."""
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(42); a1 = codeflash_output # 1.68μs -> 1.28μs (31.0% faster)

# 2. EDGE TEST CASES

def test_getAnnotator_with_zero_pixel_size():
    """Test behavior with pixel_size=0 (edge case)."""
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(0); annotator = codeflash_output # 1.68μs -> 1.25μs (33.9% faster)

def test_getAnnotator_with_negative_pixel_size():
    """Test behavior with negative pixel_size (edge case)."""
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(-1); annotator = codeflash_output # 1.74μs -> 1.32μs (32.0% faster)

def test_getAnnotator_with_large_pixel_size():
    """Test behavior with a very large pixel_size."""
    block = PixelateVisualizationBlockV1()
    large_size = 999999
    codeflash_output = block.getAnnotator(large_size); annotator = codeflash_output # 1.77μs -> 1.32μs (33.5% faster)

def test_getAnnotator_with_non_integer_pixel_size():
    """Test behavior when pixel_size is a float (should be converted to string for cache)."""
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(3.5); annotator = codeflash_output # 3.11μs -> 2.69μs (15.6% faster)

def test_getAnnotator_with_string_pixel_size():
    """Test behavior when pixel_size is a string (should be accepted, but not recommended)."""
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator("7"); annotator = codeflash_output # 1.63μs -> 1.11μs (46.4% faster)

def test_getAnnotator_with_tuple_pixel_size():
    """Test behavior when pixel_size is a tuple (should be stringified for cache)."""
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator((1,2)); annotator = codeflash_output # 2.64μs -> 2.40μs (9.87% faster)

def test_getAnnotator_with_none_pixel_size():
    """Test behavior when pixel_size is None."""
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(None); annotator = codeflash_output # 1.75μs -> 1.26μs (39.2% faster)

def test_getAnnotator_with_boolean_pixel_size():
    """Test behavior when pixel_size is a boolean."""
    block = PixelateVisualizationBlockV1()
    codeflash_output = block.getAnnotator(True); annotator_true = codeflash_output # 1.81μs -> 1.34μs (35.0% faster)
    codeflash_output = block.getAnnotator(False); annotator_false = codeflash_output # 943ns -> 705ns (33.8% faster)

# 3. LARGE SCALE TEST CASES

def test_getAnnotator_many_unique_pixel_sizes():
    """Test caching and performance with many unique pixel_sizes."""
    block = PixelateVisualizationBlockV1()
    num_sizes = 500  # Large but reasonable
    annotators = []
    for i in range(num_sizes):
        annotators.append(block.getAnnotator(i)) # 284μs -> 214μs (33.0% faster)
    # All cache keys should exist
    for i in range(num_sizes):
        pass

def test_getAnnotator_many_repeated_pixel_sizes():
    """Test that repeated calls with the same pixel_size do not create new instances."""
    block = PixelateVisualizationBlockV1()
    pixel_size = 123
    annotators = [block.getAnnotator(pixel_size) for _ in range(300)]
    # All annotators should be the same instance
    first = annotators[0]
    for a in annotators:
        pass

def test_getAnnotator_cache_memory_efficiency():
    """Test that the cache does not grow unnecessarily for repeated pixel_size values."""
    block = PixelateVisualizationBlockV1()
    for _ in range(100):
        block.getAnnotator(1) # 38.2μs -> 23.5μs (62.6% faster)
    for _ in range(100):
        block.getAnnotator(2) # 35.1μs -> 21.4μs (63.8% faster)

def test_getAnnotator_stress_test_various_types():
    """Test caching with a mix of types and values up to 1000 elements."""
    block = PixelateVisualizationBlockV1()
    keys = []
    for i in range(500):
        keys.append(i)
        keys.append(str(i))
    for k in keys:
        block.getAnnotator(k) # 468μs -> 329μs (42.4% faster)
    # All keys should be present as stringified versions
    for k in keys:
        pass
# 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-PixelateVisualizationBlockV1.getAnnotator-mh9mopv2 and push.