⚡️ Speed up method MediaImportProcessor.select_item_from_list by 442%

[codeflash-ai]

📄 442% (4.42x) speedup for MediaImportProcessor.select_item_from_list in invokeai/frontend/install/import_images.py

⏱️ Runtime : 5.40 milliseconds → 996 microseconds (best of 59 runs)

📝 Explanation and details

The optimization achieves a 441% speedup by eliminating a major performance bottleneck in the original code's item display logic.

Key Optimization: Batch Printing Instead of Per-Item Calls

The original code made individual print() calls for each item in a loop:

for item in items:
    print(f"{index}) {item}")  # Multiple syscalls
    index += 1

The optimized version uses a list comprehension with a single print() call:

lines = [f"{i}) {item}" for i, item in enumerate(items, 1)]
print('\n'.join(lines))  # Single syscall

Why This is Faster:

• Reduced I/O overhead: Each print() call involves a system call to write to stdout. For 1000 items, the original code makes 1000+ syscalls vs just 1 in the optimized version.
• Better memory locality: Building the string list in memory and joining it is more cache-friendly than repeated I/O operations.
• Eliminated loop overhead: The list comprehension with enumerate() is more efficient than manual index tracking.

Performance Impact by Scale:

• Small lists (3 items): Modest 2-6% improvements
• Large lists (1000 items): Dramatic 571-701% speedups

The optimization is particularly effective for large item lists, which appears to be a common use case based on the test scenarios. The len(items) is also cached to avoid recalculation, providing additional micro-optimizations for the boundary checks.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from unittest.mock import patch

imports

import pytest
from invokeai.frontend.install.import_images import MediaImportProcessor

unit tests

@pytest.fixture
def processor():
return MediaImportProcessor()

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

def test_select_first_item_basic(processor):
# User selects the first item from a list of three
items = ['apple', 'banana', 'cherry']
with patch('builtins.input', side_effect=['1']):
codeflash_output = processor.select_item_from_list(items, "Fruit", False, ""); result = codeflash_output # 23.8μs -> 23.2μs (2.82% faster)

def test_select_last_item_basic(processor):
# User selects the last item from a list of three
items = ['apple', 'banana', 'cherry']
with patch('builtins.input', side_effect=['3']):
codeflash_output = processor.select_item_from_list(items, "Fruit", False, ""); result = codeflash_output # 20.8μs -> 20.4μs (2.17% faster)

def test_select_middle_item_basic(processor):
# User selects the second item from a list of three
items = ['apple', 'banana', 'cherry']
with patch('builtins.input', side_effect=['2']):
codeflash_output = processor.select_item_from_list(items, "Fruit", False, ""); result = codeflash_output # 20.3μs -> 19.5μs (4.01% faster)

def test_select_with_cancel_option_select_item(processor):
# User selects a valid item when cancel is allowed
items = ['dog', 'cat', 'fish']
with patch('builtins.input', side_effect=['2']):
codeflash_output = processor.select_item_from_list(items, "Animal", True, "Cancel"); result = codeflash_output # 21.5μs -> 21.5μs (0.088% slower)

def test_select_with_cancel_option_cancel(processor):
# User selects the cancel option
items = ['dog', 'cat', 'fish']
with patch('builtins.input', side_effect=['4']):
codeflash_output = processor.select_item_from_list(items, "Animal", True, "Cancel"); result = codeflash_output # 21.5μs -> 20.2μs (6.26% faster)

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

def test_select_with_empty_list(processor):
# If the list is empty, only cancel is available if allow_cancel=True
items = []
with patch('builtins.input', side_effect=['1']):
codeflash_output = processor.select_item_from_list(items, "Nothing", True, "Cancel"); result = codeflash_output # 17.7μs -> 17.7μs (0.062% slower)

def test_select_with_empty_list_no_cancel(processor):
# If the list is empty and cancel is not allowed, function should not accept any input
# This test will simulate a user entering '1' and then '2', but function will not return
# To avoid infinite loop, we use pytest.raises with a timeout
items = []
with patch('builtins.input', side_effect=['1', '2', '3', '4', '5']):
with pytest.raises(StopIteration):
# StopIteration occurs when side_effect is exhausted
next(processor.select_item_from_list(items, "Nothing", False, "Cancel") for _ in range(5))

def test_select_with_non_integer_input_then_valid(processor):
# User enters a non-integer, then a valid integer
items = ['x', 'y', 'z']
with patch('builtins.input', side_effect=['foo', '2']):
codeflash_output = processor.select_item_from_list(items, "Letter", False, ""); result = codeflash_output # 29.6μs -> 29.4μs (0.643% faster)

def test_select_with_out_of_range_input_then_valid(processor):
# User enters an out-of-range number, then a valid one
items = ['x', 'y', 'z']
with patch('builtins.input', side_effect=['0', '5', '3']):
codeflash_output = processor.select_item_from_list(items, "Letter", False, ""); result = codeflash_output # 30.7μs -> 29.2μs (5.07% faster)

def test_select_with_negative_input_then_valid(processor):
# User enters a negative number, then a valid number
items = ['x', 'y', 'z']
with patch('builtins.input', side_effect=['-1', '1']):
codeflash_output = processor.select_item_from_list(items, "Letter", False, ""); result = codeflash_output # 26.2μs -> 25.0μs (4.53% faster)

def test_select_with_multiple_invalids_then_cancel(processor):
# User enters several invalid inputs, then selects cancel
items = ['a', 'b']
with patch('builtins.input', side_effect=['foo', '0', '3']):
codeflash_output = processor.select_item_from_list(items, "Letter", True, "Cancel"); result = codeflash_output # 33.3μs -> 33.3μs (0.015% faster)

def test_select_with_whitespace_input_then_valid(processor):
# User enters whitespace, then a valid number
items = ['a', 'b']
with patch('builtins.input', side_effect=[' ', '1']):
codeflash_output = processor.select_item_from_list(items, "Letter", False, ""); result = codeflash_output # 27.3μs -> 27.4μs (0.721% slower)

def test_select_with_large_integer_then_valid(processor):
# User enters a very large integer, then a valid one
items = ['a', 'b']
with patch('builtins.input', side_effect=['999999', '2']):
codeflash_output = processor.select_item_from_list(items, "Letter", False, ""); result = codeflash_output # 24.9μs -> 25.9μs (3.83% slower)

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

def test_select_first_item_large_list(processor):
# User selects the first item from a large list
items = [f'item{i}' for i in range(1, 1001)]
with patch('builtins.input', side_effect=['1']):
codeflash_output = processor.select_item_from_list(items, "Item", False, ""); result = codeflash_output # 1.01ms -> 128μs (685% faster)

def test_select_last_item_large_list(processor):
# User selects the last item from a large list
items = [f'item{i}' for i in range(1, 1001)]
with patch('builtins.input', side_effect=['1000']):
codeflash_output = processor.select_item_from_list(items, "Item", False, ""); result = codeflash_output # 1.00ms -> 125μs (701% faster)

def test_select_cancel_large_list(processor):
# User selects the cancel option in a large list
items = [f'item{i}' for i in range(1, 1000)]
with patch('builtins.input', side_effect=['1000']):
codeflash_output = processor.select_item_from_list(items, "Item", True, "Cancel"); result = codeflash_output # 1.00ms -> 127μs (690% faster)

def test_select_middle_item_large_list(processor):
# User selects a middle item from a large list
items = [f'item{i}' for i in range(1, 1001)]
with patch('builtins.input', side_effect=['500']):
codeflash_output = processor.select_item_from_list(items, "Item", False, ""); result = codeflash_output # 1.01ms -> 127μs (692% faster)

def test_select_with_many_invalids_then_valid_large_list(processor):
# User enters many invalid inputs, then a valid one in a large list
items = [f'item{i}' for i in range(1, 1001)]
with patch('builtins.input', side_effect=['-1', '0', '1001', 'foo', '1000']):
codeflash_output = processor.select_item_from_list(items, "Item", False, ""); result = codeflash_output # 1.03ms -> 153μs (571% 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
from invokeai.frontend.install.import_images import MediaImportProcessor

unit tests

Helper function to patch input for testing

class InputPatcher:
"""Context manager to patch the built-in input() function for test purposes."""
def init(self, responses):
self.responses = responses
self.index = 0
self.original_input = None

def __enter__(self):
    self.original_input = __builtins__.input
    __builtins__.input = self.fake_input
    return self

def __exit__(self, exc_type, exc_value, traceback):
    __builtins__.input = self.original_input

def fake_input(self, prompt):
    if self.index >= len(self.responses):
        raise RuntimeError("No more responses left for input()")
    resp = self.responses[self.index]
    self.index += 1
    return resp

Basic Test Cases

To edit these changes git checkout codeflash/optimize-MediaImportProcessor.select_item_from_list-mhvddlu2 and push.