⚡️ Speed up function get_rolling_shutter_readout by 11%

[codeflash-ai]

📄 11% (0.11x) speedup for get_rolling_shutter_readout in opendm/rollingshutter.py

⏱️ Runtime : 587 microseconds → 528 microseconds (best of 257 runs)

📝 Explanation and details

The optimized code achieves an 11% speedup through several targeted micro-optimizations:

String formatting optimization in make_model_key: The original used old-style string formatting ("%s %s" % (make.strip(), model.strip())).lower().strip() which creates multiple intermediate string objects. The optimized version uses an f-string f"{make.strip()} {model.strip()}".lower() which is more efficient and eliminates the final .strip() call since f-strings don't add extra whitespace.

Type checking optimization: Replaced isinstance(rsd, int) or isinstance(rsd, float) with rsd_type = type(rsd); if rsd_type is int or rsd_type is float. This avoids the overhead of two isinstance() calls by caching the type and using faster identity comparisons with is.

Variable localization: Added local references like db = RS_DATABASE, _log = log, info_dict = info_db_found, and warn_dict = warn_db_missing. This reduces attribute/global lookups in the hot path, as Python can access local variables faster than globals or module attributes.

Import optimization: Added explicit imports for the global variables to avoid runtime lookups.

These optimizations are particularly effective for the test cases shown, with improvements ranging from 5-25% across different scenarios. The gains are most pronounced in cases with many database lookups (like the large-scale tests showing 11-14% improvements) and when processing known cameras with simple numeric values (up to 25% faster for some float lookups). The optimizations maintain identical functionality while reducing Python interpreter overhead.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from opendm.rollingshutter import get_rolling_shutter_readout

# function to test
# (See code block above for function definition; assumed present in test context.)

# --- Helper Classes and Functions ---

class DummyPhoto:
    """A dummy photo object for testing get_rolling_shutter_readout."""
    def __init__(self, camera_make, camera_model, capture_megapixels=None):
        self.camera_make = camera_make
        self.camera_model = camera_model
        self._capture_megapixels = capture_megapixels

    def get_capture_megapixels(self):
        # If not specified, raise AttributeError to simulate missing method
        if self._capture_megapixels is None:
            raise AttributeError("get_capture_megapixels not implemented")
        return self._capture_megapixels

# Patch the log module to avoid side effects during testing
class DummyLog:
    def __init__(self):
        self.warnings = []
        self.infos = []
    def ODM_WARNING(self, msg):
        self.warnings.append(msg)
    def ODM_INFO(self, msg):
        self.infos.append(msg)

@pytest.fixture(autouse=True)
def patch_log(monkeypatch):
    dummy_log = DummyLog()
    monkeypatch.setattr("opendm.rollingshutter.log", dummy_log)
    # Also patch global log reference in local module scope
    import sys
    sys.modules['opendm.log'] = dummy_log
    yield dummy_log

# --- Basic Test Cases ---

def test_known_camera_int_readout():
    # Test with a camera in RS_DATABASE with int readout value
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo) # 2.03μs -> 1.84μs (10.0% faster)

def test_known_camera_float_readout():
    # Test with a camera in RS_DATABASE with float readout value
    photo = DummyPhoto("Hasselblad", "L2D-20c")
    codeflash_output = get_rolling_shutter_readout(photo) # 2.25μs -> 1.83μs (22.9% faster)

def test_known_camera_lambda_readout_below_threshold():
    # Test lambda entry with megapixels below threshold
    photo = DummyPhoto("DJI", "FC7203", capture_megapixels=9)
    codeflash_output = get_rolling_shutter_readout(photo) # 2.84μs -> 2.64μs (7.61% faster)

def test_known_camera_lambda_readout_above_threshold():
    # Test lambda entry with megapixels above threshold
    photo = DummyPhoto("DJI", "FC7203", capture_megapixels=12)
    codeflash_output = get_rolling_shutter_readout(photo) # 2.65μs -> 2.38μs (11.3% faster)

def test_known_camera_lambda_multiple_thresholds():
    # Test complex lambda with multiple thresholds
    photo = DummyPhoto("DJI", "FC8482", capture_megapixels=11)
    codeflash_output = get_rolling_shutter_readout(photo) # 2.67μs -> 2.42μs (10.1% faster)
    photo = DummyPhoto("DJI", "FC8482", capture_megapixels=15)
    codeflash_output = get_rolling_shutter_readout(photo) # 1.42μs -> 1.24μs (14.9% faster)
    photo = DummyPhoto("DJI", "FC8482", capture_megapixels=40)
    codeflash_output = get_rolling_shutter_readout(photo) # 999ns -> 921ns (8.47% faster)
    photo = DummyPhoto("DJI", "FC8482", capture_megapixels=48.8)
    codeflash_output = get_rolling_shutter_readout(photo) # 1.04μs -> 917ns (13.0% faster)

def test_case_insensitivity_and_whitespace():
    # Test that make/model is case-insensitive and whitespace is stripped
    photo = DummyPhoto("  dJi  ", "  fc300s ")
    codeflash_output = get_rolling_shutter_readout(photo) # 2.10μs -> 1.92μs (9.49% faster)

def test_override_value():
    # Test that override_value takes precedence over database
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo, override_value=99) # 659ns -> 737ns (10.6% slower)

def test_unknown_camera_returns_default_and_warns(patch_log):
    # Camera not in database should return DEFAULT_RS_READOUT and warn
    photo = DummyPhoto("UnknownMake", "UnknownModel")
    codeflash_output = get_rolling_shutter_readout(photo); val = codeflash_output # 2.09μs -> 1.99μs (5.44% faster)

def test_known_camera_info_logged_once(patch_log):
    # Info should be logged only once for a known camera
    photo = DummyPhoto("DJI", "FC300S")
    get_rolling_shutter_readout(photo) # 2.06μs -> 1.80μs (14.5% faster)
    get_rolling_shutter_readout(photo) # 997ns -> 891ns (11.9% faster)

# --- Edge Test Cases ---

def test_camera_with_empty_make_and_model():
    # Empty make/model should return default and warn
    photo = DummyPhoto("", "")
    codeflash_output = get_rolling_shutter_readout(photo); val = codeflash_output # 1.86μs -> 1.68μs (10.3% faster)

def test_camera_with_only_whitespace_make_and_model():
    # Whitespace make/model should return default and warn
    photo = DummyPhoto("   ", "  ")
    codeflash_output = get_rolling_shutter_readout(photo); val = codeflash_output # 1.82μs -> 1.70μs (7.17% faster)

def test_camera_with_missing_get_capture_megapixels():
    # Lambda expects get_capture_megapixels but method is missing
    photo = DummyPhoto("DJI", "FC7203")
    with pytest.raises(AttributeError):
        get_rolling_shutter_readout(photo) # 3.20μs -> 2.87μs (11.4% faster)

def test_camera_with_non_numeric_megapixels():
    # Lambda expects numeric megapixels, but receives a string
    photo = DummyPhoto("DJI", "FC7203", capture_megapixels="twelve")
    with pytest.raises(TypeError):
        get_rolling_shutter_readout(photo) # 3.71μs -> 3.60μs (2.95% faster)


def test_override_value_zero_returns_database_value():
    # override_value=0 should not override the database value
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo, override_value=0) # 3.30μs -> 2.91μs (13.5% faster)

def test_override_value_negative_returns_database_value():
    # Negative override_value should not override the database value
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo, override_value=-5) # 2.52μs -> 2.20μs (14.2% faster)

def test_multiple_unknown_cameras_warn_once_each(patch_log):
    # Each unknown camera should warn once
    photo1 = DummyPhoto("Unknown", "ModelA")
    photo2 = DummyPhoto("Unknown", "ModelB")
    get_rolling_shutter_readout(photo1) # 1.99μs -> 1.96μs (1.53% faster)
    get_rolling_shutter_readout(photo2) # 871ns -> 789ns (10.4% faster)

def test_multiple_calls_to_unknown_camera_warn_once(patch_log):
    # Multiple calls for same unknown camera should warn only once
    photo = DummyPhoto("Unknown", "ModelC")
    get_rolling_shutter_readout(photo) # 1.69μs -> 1.63μs (3.81% faster)
    get_rolling_shutter_readout(photo) # 773ns -> 711ns (8.72% faster)

# --- Large Scale Test Cases ---

def test_many_known_cameras_performance():
    # Test performance and correctness with many known cameras
    for i in range(100):
        make = "DJI"
        model = "FC300S"
        photo = DummyPhoto(make, model)
        codeflash_output = get_rolling_shutter_readout(photo) # 51.6μs -> 46.4μs (11.3% faster)

def test_many_unknown_cameras_performance():
    # Test performance and correctness with many unknown cameras
    for i in range(100):
        make = "UnknownMake"
        model = f"UnknownModel{i}"
        photo = DummyPhoto(make, model)
        codeflash_output = get_rolling_shutter_readout(photo) # 51.6μs -> 45.1μs (14.3% faster)

def test_many_lambda_cameras_varied_megapixels():
    # Test lambda cameras with varied megapixels
    for mp in range(1, 50, 5):  # 1, 6, 11, ..., 46
        photo = DummyPhoto("DJI", "FC3582", capture_megapixels=mp)
        expected = 26.0 if mp < 48 else 60.0
        codeflash_output = get_rolling_shutter_readout(photo) # 9.58μs -> 8.57μs (11.8% faster)


def test_many_info_and_warn_logs(patch_log):
    # Ensure info/warn logs are produced for many unique cameras
    for i in range(50):
        photo1 = DummyPhoto("DJI", "FC300S")
        photo2 = DummyPhoto("Unknown", f"Model{i}")
        get_rolling_shutter_readout(photo1) # 29.2μs -> 26.0μs (12.5% faster)
        get_rolling_shutter_readout(photo2) # 26.5μs -> 23.6μs (12.3% 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 opendm.rollingshutter import get_rolling_shutter_readout


# --- Begin: Function to test (direct copy from provided code) ---
# Make Model (lowercase) --> readout time (ms)
class log:
    @staticmethod
    def ODM_WARNING(msg): pass
    @staticmethod
    def ODM_INFO(msg): pass

RS_DATABASE = {
    'autel robotics xt701': 25, # Autel Evo II 8k 
    'dji phantom vision fc200': 74, # Phantom 2
    'dji fc300s': 33, # Phantom 3 Advanced
    'dji fc300c': 33, # Phantom 3 Standard
    'dji fc300x': 33, # Phantom 3 Professional
    'dji fc330': 33, # Phantom 4
    'dji fc6310': 33, # Phantom 4 Professional
    'dji fc7203': lambda p: 19 if p.get_capture_megapixels() < 10 else 25, # DJI Mavic Mini v1
    'dji fc2103': 32, # DJI Mavic Air 1
    'dji fc3170': 27, # DJI Mavic Air 2
    'dji fc3411': 32, # DJI Mavic Air 2S
    'dji fc220': 64, # DJI Mavic Pro (Platinum)
    'hasselblad l1d-20c': lambda p: 47 if p.get_capture_megapixels() < 17 else 56, # DJI Mavic 2 Pro
    'hasselblad l2d-20c': 16.6, # DJI Mavic 3
    'dji fc3582': lambda p: 26 if p.get_capture_megapixels() < 48 else 60, # DJI Mini 3 pro
    'dji fc8482': lambda p: (
        16 if p.get_capture_megapixels() < 12 else
        21 if p.get_capture_megapixels() < 20 else
        43 if p.get_capture_megapixels() < 45 else
        58
    ), # DJI Mini 4 Pro
    'dji fc350': 30, # Inspire 1
    'dji mavic2-enterprise-advanced': 31, # DJI Mavic 2 Enterprise Advanced
    'dji zenmuse z30': 8, # DJI Zenmuse Z30
    'yuneec e90': 44, # Yuneec E90
    'gopro hero4 black': 30, # GoPro Hero 4 Black
    'gopro hero8 black': 17, # GoPro Hero 8 Black
    'teracube teracube one': 32, # TeraCube TeraCube_One TR1907Q Mobile Phone
    'fujifilm x-a5': 186, # FUJIFILM X-A5
    'fujifilm x-t2': 35, # FUJIFILM X-T2
    'autel robotics xl724': 29, # Autel Nano+
    'parrot anafi': 39, # Parrot Anafi
    'autel robotics xt705': 30, # Autel EVO II pro
}
DEFAULT_RS_READOUT = 30 # Just a guess

warn_db_missing = {}
info_db_found = {}
from opendm.rollingshutter import \
    get_rolling_shutter_readout  # --- End: Function to test ---


# --- Begin: Unit tests ---
# Helper class for photo objects
class DummyPhoto:
    def __init__(self, make, model, megapixels=None):
        self.camera_make = make
        self.camera_model = model
        self._megapixels = megapixels
    def get_capture_megapixels(self):
        if self._megapixels is None:
            raise AttributeError("No megapixels set")
        return self._megapixels

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

def test_basic_known_camera_int_value():
    # Test a camera with a direct integer value in RS_DATABASE
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo) # 1.99μs -> 1.87μs (6.48% faster)

def test_basic_known_camera_float_value():
    # Test a camera with a direct float value in RS_DATABASE
    photo = DummyPhoto("Hasselblad", "L2D-20C")
    codeflash_output = get_rolling_shutter_readout(photo) # 2.05μs -> 1.64μs (25.0% faster)

def test_basic_known_camera_lambda_low_megapixels():
    # Test a camera with lambda value, low megapixels branch
    photo = DummyPhoto("DJI", "FC7203", megapixels=8.9)
    codeflash_output = get_rolling_shutter_readout(photo) # 2.69μs -> 2.38μs (13.1% faster)

def test_basic_known_camera_lambda_high_megapixels():
    # Test a camera with lambda value, high megapixels branch
    photo = DummyPhoto("DJI", "FC7203", megapixels=12)
    codeflash_output = get_rolling_shutter_readout(photo) # 2.18μs -> 1.99μs (9.33% faster)

def test_basic_override_value():
    # Test override_value parameter
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo, override_value=99) # 736ns -> 836ns (12.0% slower)

def test_basic_unknown_camera_returns_default():
    # Test unknown camera returns default value
    photo = DummyPhoto("Unknown", "UnknownModel")
    codeflash_output = get_rolling_shutter_readout(photo) # 1.87μs -> 1.77μs (5.58% faster)

def test_basic_case_and_whitespace_handling():
    # Test that make/model casing and whitespace does not affect lookup
    photo = DummyPhoto("  dJi  ", "Fc300S ")
    codeflash_output = get_rolling_shutter_readout(photo) # 2.07μs -> 1.89μs (9.25% faster)

def test_basic_lambda_multiple_branches():
    # Test DJI Mini 4 Pro lambda with all branches
    # 9.1MP -> <12 branch
    photo = DummyPhoto("DJI", "FC8482", megapixels=9.1)
    codeflash_output = get_rolling_shutter_readout(photo) # 2.43μs -> 2.32μs (4.87% faster)
    # 12.2MP -> <20 branch
    photo = DummyPhoto("DJI", "FC8482", megapixels=12.2)
    codeflash_output = get_rolling_shutter_readout(photo) # 1.17μs -> 1.07μs (9.17% faster)
    # 36.6MP -> <45 branch
    photo = DummyPhoto("DJI", "FC8482", megapixels=36.6)
    codeflash_output = get_rolling_shutter_readout(photo) # 976ns -> 868ns (12.4% faster)
    # 48.8MP -> else branch
    photo = DummyPhoto("DJI", "FC8482", megapixels=48.8)
    codeflash_output = get_rolling_shutter_readout(photo) # 877ns -> 800ns (9.62% faster)

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

def test_edge_override_zero_returns_database_value():
    # Test that override_value=0 does not override
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo, override_value=0) # 1.84μs -> 1.77μs (3.73% faster)

def test_edge_override_negative_returns_database_value():
    # Negative override_value should not override
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo, override_value=-10) # 1.82μs -> 1.72μs (6.10% faster)

def test_edge_missing_megapixels_for_lambda_raises():
    # If lambda expects megapixels but photo doesn't provide, should raise
    photo = DummyPhoto("DJI", "FC7203")
    with pytest.raises(AttributeError):
        get_rolling_shutter_readout(photo) # 2.56μs -> 2.37μs (8.02% faster)

def test_edge_make_model_with_extra_spaces():
    # Make/model with excessive whitespace should be trimmed
    photo = DummyPhoto("   DJI   ", "   FC300S   ")
    codeflash_output = get_rolling_shutter_readout(photo) # 2.02μs -> 1.90μs (6.21% faster)

def test_edge_make_model_case_insensitivity():
    # Make/model with different casing should match
    photo = DummyPhoto("dji", "fc300s")
    codeflash_output = get_rolling_shutter_readout(photo) # 1.67μs -> 1.57μs (5.91% faster)
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo) # 677ns -> 641ns (5.62% faster)
    photo = DummyPhoto("Dji", "Fc300s")
    codeflash_output = get_rolling_shutter_readout(photo) # 550ns -> 543ns (1.29% faster)

def test_edge_lambda_float_return():
    # Test lambda that returns float
    photo = DummyPhoto("DJI", "FC3582", megapixels=47.9)
    codeflash_output = get_rolling_shutter_readout(photo) # 2.23μs -> 2.12μs (5.00% faster)
    photo = DummyPhoto("DJI", "FC3582", megapixels=48)
    codeflash_output = get_rolling_shutter_readout(photo) # 1.14μs -> 999ns (14.2% faster)

def test_edge_invalid_rsd_type_returns_default():
    # Add a bogus entry to RS_DATABASE to test fallback
    RS_DATABASE["test invalid type"] = "not a number or callable"
    photo = DummyPhoto("test", "invalid type")
    codeflash_output = get_rolling_shutter_readout(photo) # 1.52μs -> 1.57μs (3.24% slower)
    RS_DATABASE.pop("test invalid type") # Clean up

def test_edge_warn_db_missing_only_once(monkeypatch):
    # Test that warn_db_missing is only triggered once per unknown key
    warnings = []
    monkeypatch.setattr(log, "ODM_WARNING", lambda msg: warnings.append(msg))
    photo = DummyPhoto("Unknown", "UnknownModel")
    get_rolling_shutter_readout(photo) # 1.53μs -> 1.47μs (4.50% faster)
    get_rolling_shutter_readout(photo) # 657ns -> 635ns (3.46% faster)

def test_edge_info_db_found_only_once(monkeypatch):
    # Test that info_db_found is only triggered once per known key
    infos = []
    monkeypatch.setattr(log, "ODM_INFO", lambda msg: infos.append(msg))
    photo = DummyPhoto("DJI", "FC300S")
    get_rolling_shutter_readout(photo) # 1.69μs -> 1.52μs (11.0% faster)
    get_rolling_shutter_readout(photo) # 745ns -> 627ns (18.8% faster)

def test_edge_lambda_branch_boundaries():
    # Test boundary values for lambda branches
    photo = DummyPhoto("DJI", "FC8482", megapixels=12)
    codeflash_output = get_rolling_shutter_readout(photo) # 2.29μs -> 2.24μs (2.19% faster)
    photo = DummyPhoto("DJI", "FC8482", megapixels=20)
    codeflash_output = get_rolling_shutter_readout(photo) # 1.23μs -> 1.12μs (10.2% faster)
    photo = DummyPhoto("DJI", "FC8482", megapixels=45)
    codeflash_output = get_rolling_shutter_readout(photo) # 994ns -> 862ns (15.3% faster)

def test_edge_make_model_with_leading_and_trailing_spaces():
    # Test that leading/trailing spaces in make/model are handled
    photo = DummyPhoto(" DJI ", " FC300S ")
    codeflash_output = get_rolling_shutter_readout(photo) # 1.70μs -> 1.66μs (1.98% faster)

def test_edge_override_value_float():
    # Test that override_value can be a float
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo, override_value=12.5) # 687ns -> 718ns (4.32% slower)

def test_edge_override_value_large():
    # Test that override_value can be very large
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo, override_value=1e6) # 615ns -> 666ns (7.66% slower)

def test_edge_override_value_small_positive():
    # Test that override_value can be a small positive float
    photo = DummyPhoto("DJI", "FC300S")
    codeflash_output = get_rolling_shutter_readout(photo, override_value=0.0001) # 615ns -> 648ns (5.09% slower)

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

def test_large_scale_many_known_cameras():
    # Test with many known cameras for performance and correctness
    for key, value in list(RS_DATABASE.items())[:100]:  # up to 100 entries
        make, model = key.split(" ", 1)
        if callable(value):
            # Use a reasonable megapixel value for callable
            photo = DummyPhoto(make, model, megapixels=15)
            codeflash_output = get_rolling_shutter_readout(photo); result = codeflash_output
        else:
            photo = DummyPhoto(make, model)
            codeflash_output = get_rolling_shutter_readout(photo); result = codeflash_output

def test_large_scale_many_unknown_cameras():
    # Test with many unknown cameras for performance and correctness
    for i in range(100):
        photo = DummyPhoto(f"UnknownMake{i}", f"UnknownModel{i}")
        codeflash_output = get_rolling_shutter_readout(photo) # 52.4μs -> 47.2μs (11.0% faster)

def test_large_scale_many_different_megapixels():
    # Test lambda cameras with a wide range of megapixels
    photo = DummyPhoto("DJI", "FC8482", megapixels=5)
    codeflash_output = get_rolling_shutter_readout(photo) # 2.28μs -> 2.18μs (4.55% faster)
    photo = DummyPhoto("DJI", "FC8482", megapixels=15)
    codeflash_output = get_rolling_shutter_readout(photo) # 1.13μs -> 999ns (13.4% faster)
    photo = DummyPhoto("DJI", "FC8482", megapixels=30)
    codeflash_output = get_rolling_shutter_readout(photo) # 941ns -> 860ns (9.42% faster)
    photo = DummyPhoto("DJI", "FC8482", megapixels=60)
    codeflash_output = get_rolling_shutter_readout(photo) # 886ns -> 760ns (16.6% faster)

def test_large_scale_info_db_found_and_warn_db_missing_growth(monkeypatch):
    # Test that info_db_found and warn_db_missing grow with unique keys
    infos = []
    warnings = []
    monkeypatch.setattr(log, "ODM_INFO", lambda msg: infos.append(msg))
    monkeypatch.setattr(log, "ODM_WARNING", lambda msg: warnings.append(msg))
    # Known keys
    for i in range(30):
        photo = DummyPhoto("DJI", "FC300S")
        get_rolling_shutter_readout(photo) # 16.7μs -> 15.0μs (11.2% faster)
    # Unknown keys
    for i in range(30):
        photo = DummyPhoto(f"UnknownMake{i}", f"UnknownModel{i}")
        get_rolling_shutter_readout(photo) # 15.6μs -> 13.9μs (12.3% faster)

def test_large_scale_lambda_branch_distribution():
    # Test distribution of lambda branches for DJI Mini 4 Pro
    counts = {16:0, 21:0, 43:0, 58:0}
    # 0-11.99: 16, 12-19.99: 21, 20-44.99: 43, 45+: 58
    for mp in range(0, 60, 5):  # 0, 5, ..., 55
        photo = DummyPhoto("DJI", "FC8482", megapixels=mp)
        codeflash_output = get_rolling_shutter_readout(photo); val = codeflash_output # 11.4μs -> 10.2μs (11.0% faster)
        counts[val] += 1
    # Should have at least one for each branch
    for v in counts.values():
        pass

def test_large_scale_lambda_callable_performance():
    # Test performance with many lambda calls
    for i in range(200):
        mp = (i % 50) + 1
        photo = DummyPhoto("DJI", "FC8482", megapixels=mp)
        codeflash_output = get_rolling_shutter_readout(photo); val = codeflash_output # 153μs -> 137μs (12.0% faster)

def test_large_scale_make_model_variants():
    # Test make/model variants for 100 known cameras
    keys = list(RS_DATABASE.keys())[:100]
    for key in keys:
        make, model = key.split(" ", 1)
        for variant in [make.upper(), make.lower(), make.title()]:
            photo = DummyPhoto(variant, model)
            # If callable, supply megapixels
            value = RS_DATABASE[key]
            if callable(value):
                codeflash_output = get_rolling_shutter_readout(DummyPhoto(variant, model, megapixels=15)); result = codeflash_output
            else:
                codeflash_output = get_rolling_shutter_readout(photo); result = codeflash_output
# 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_rolling_shutter_readout-mh4gpr91 and push.