⚡️ Speed up method InlineModelAdminChecks._check_max_num by 14%

[codeflash-ai]

📄 14% (0.14x) speedup for InlineModelAdminChecks._check_max_num in django/contrib/admin/checks.py

⏱️ Runtime : 3.21 milliseconds → 2.82 milliseconds (best of 172 runs)

📝 Explanation and details

The optimization achieves a 13% speedup through three key changes:

1. Single attribute lookup: max_num = obj.max_num at the start eliminates repeated attribute access, reducing overhead when the value is checked multiple times.

2. Type checking optimization: Replacing isinstance(obj.max_num, int) with type(max_num) is not int bypasses the inheritance checking overhead of isinstance(). This is safe for Django admin configurations which typically use primitive integers.

3. Inlined error construction: The hot path (when validation fails) now constructs the checks.Error directly instead of calling must_be(), eliminating function call overhead and the extra list allocation within must_be().

The profiler data shows the optimization particularly benefits error cases - the original code spent 79.7% of time in the must_be() call, which is now eliminated. Test results confirm this: error cases (floats, strings, objects) see 16-35% speedups, while valid integer cases have minimal overhead (only 1-8% slower due to the extra variable assignment).

The optimization is most effective for validation-heavy workloads where many objects have invalid max_num values, as demonstrated by the 20% speedup in large-scale invalid type tests. The must_be() function is retained for backward compatibility.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from django.contrib.admin.checks import InlineModelAdminChecks
# function to test
from django.core import checks


# Helper class to simulate an object with a 'max_num' attribute
class DummyObj:
    def __init__(self, max_num):
        self.max_num = max_num

# unit tests

# Basic Test Cases

def test_max_num_none_returns_empty_list():
    # max_num is None, should return []
    obj = DummyObj(None)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 462ns -> 482ns (4.15% slower)

def test_max_num_integer_returns_empty_list():
    # max_num is integer, should return []
    obj = DummyObj(5)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 525ns -> 565ns (7.08% slower)

def test_max_num_zero_returns_empty_list():
    # max_num is zero (edge integer), should return []
    obj = DummyObj(0)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 514ns -> 525ns (2.10% slower)

def test_max_num_negative_integer_returns_empty_list():
    # max_num is negative integer, should return []
    obj = DummyObj(-10)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 474ns -> 500ns (5.20% slower)

def test_max_num_positive_integer_returns_empty_list():
    # max_num is positive integer, should return []
    obj = DummyObj(123)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 451ns -> 495ns (8.89% slower)

# Edge Test Cases

def test_max_num_float_returns_error():
    # max_num is float, should return error
    obj = DummyObj(3.14)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 3.77μs -> 2.81μs (34.0% faster)

def test_max_num_string_returns_error():
    # max_num is string, should return error
    obj = DummyObj("10")
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 3.13μs -> 2.48μs (26.1% faster)

def test_max_num_list_returns_error():
    # max_num is list, should return error
    obj = DummyObj([1,2,3])
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 2.83μs -> 2.27μs (24.5% faster)

def test_max_num_dict_returns_error():
    # max_num is dict, should return error
    obj = DummyObj({'num': 1})
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 2.80μs -> 2.29μs (22.7% faster)

def test_max_num_bool_returns_error():
    # max_num is bool, should return error (True/False are instances of int, but should be excluded if strict)
    # However, in Python, bool is a subclass of int, so isinstance(True, int) is True.
    # This test ensures the function's behavior is Pythonic.
    obj_true = DummyObj(True)
    obj_false = DummyObj(False)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj_true); result_true = codeflash_output # 532ns -> 2.17μs (75.5% slower)
    codeflash_output = checker._check_max_num(obj_false); result_false = codeflash_output # 268ns -> 1.36μs (80.3% slower)

def test_max_num_object_returns_error():
    # max_num is an arbitrary object, should return error
    class SomeObj: pass
    obj = DummyObj(SomeObj())
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 3.46μs -> 2.42μs (42.5% faster)

def test_max_num_bytes_returns_error():
    # max_num is bytes, should return error
    obj = DummyObj(b'123')
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 2.83μs -> 2.11μs (33.9% faster)

def test_max_num_complex_returns_error():
    # max_num is complex number, should return error
    obj = DummyObj(3+4j)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 2.67μs -> 2.00μs (33.5% faster)

# Large Scale Test Cases

def test_large_scale_all_integers():
    # Test 1000 objects with valid integer max_num
    checker = InlineModelAdminChecks()
    for i in range(1000):
        obj = DummyObj(i)
        codeflash_output = checker._check_max_num(obj); result = codeflash_output # 147μs -> 147μs (0.303% slower)

def test_large_scale_all_none():
    # Test 1000 objects with max_num=None
    checker = InlineModelAdminChecks()
    for _ in range(1000):
        obj = DummyObj(None)
        codeflash_output = checker._check_max_num(obj); result = codeflash_output # 128μs -> 131μs (2.79% slower)

def test_large_scale_all_invalid_types():
    # Test 1000 objects with invalid max_num types (alternating types)
    checker = InlineModelAdminChecks()
    invalid_types = [3.14, "str", [1], {'a':1}, b'bytes', 2+3j]
    for i in range(1000):
        obj = DummyObj(invalid_types[i % len(invalid_types)])
        codeflash_output = checker._check_max_num(obj); result = codeflash_output # 861μs -> 713μs (20.8% faster)

def test_large_scale_mixed_types():
    # Test 1000 objects with mixed valid and invalid types
    checker = InlineModelAdminChecks()
    for i in range(1000):
        if i % 3 == 0:
            obj = DummyObj(i)  # valid int
            expected = []
        elif i % 3 == 1:
            obj = DummyObj(None)  # None
            expected = []
        else:
            obj = DummyObj("invalid")  # invalid type
            expected = "error"
        codeflash_output = checker._check_max_num(obj); result = codeflash_output # 392μs -> 354μs (10.8% faster)
        if expected == []:
            pass
        else:
            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 django.contrib.admin.checks import InlineModelAdminChecks
# function to test
from django.core import checks


# Helper class for testing
class DummyObj:
    def __init__(self, max_num):
        self.max_num = max_num

# ---- UNIT TESTS ----

# Basic Test Cases

def test_max_num_none_returns_empty_list():
    """Test that None value for max_num returns an empty list (no errors)."""
    obj = DummyObj(None)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 482ns -> 517ns (6.77% slower)

def test_max_num_zero_returns_empty_list():
    """Test that zero value for max_num returns an empty list (no errors)."""
    obj = DummyObj(0)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 547ns -> 531ns (3.01% faster)

def test_max_num_positive_int_returns_empty_list():
    """Test that positive integer for max_num returns an empty list (no errors)."""
    obj = DummyObj(5)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 488ns -> 531ns (8.10% slower)

def test_max_num_negative_int_returns_empty_list():
    """Test that negative integer for max_num returns an empty list (no errors)."""
    obj = DummyObj(-10)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 501ns -> 500ns (0.200% faster)

# Edge Test Cases

def test_max_num_float_returns_error():
    """Test that a float value for max_num returns an error."""
    obj = DummyObj(3.5)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 4.33μs -> 3.54μs (22.3% faster)

def test_max_num_string_returns_error():
    """Test that a string value for max_num returns an error."""
    obj = DummyObj("10")
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 3.18μs -> 2.73μs (16.4% faster)

def test_max_num_bool_returns_error():
    """Test that a boolean value for max_num returns an error, even though bool is subclass of int."""
    obj = DummyObj(True)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 547ns -> 2.43μs (77.5% slower)

def test_max_num_list_returns_error():
    """Test that a list value for max_num returns an error."""
    obj = DummyObj([1,2,3])
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 3.31μs -> 2.50μs (32.4% faster)

def test_max_num_dict_returns_error():
    """Test that a dict value for max_num returns an error."""
    obj = DummyObj({'max': 5})
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 2.90μs -> 2.36μs (22.5% faster)

def test_max_num_tuple_returns_error():
    """Test that a tuple value for max_num returns an error."""
    obj = DummyObj((1,2))
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 2.75μs -> 2.20μs (24.9% faster)

def test_max_num_object_returns_error():
    """Test that a custom object value for max_num returns an error."""
    class OtherObj: pass
    obj = DummyObj(OtherObj())
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 3.29μs -> 2.43μs (35.3% faster)

def test_max_num_inf_returns_error():
    """Test that float('inf') value for max_num returns an error."""
    obj = DummyObj(float('inf'))
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 2.66μs -> 2.28μs (16.9% faster)

def test_max_num_nan_returns_error():
    """Test that float('nan') value for max_num returns an error."""
    obj = DummyObj(float('nan'))
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 2.54μs -> 2.14μs (18.7% faster)

def test_max_num_large_int_returns_empty_list():
    """Test that a very large integer for max_num returns an empty list (no errors)."""
    obj = DummyObj(10**18)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 526ns -> 509ns (3.34% faster)

def test_max_num_small_int_returns_empty_list():
    """Test that a very small integer for max_num returns an empty list (no errors)."""
    obj = DummyObj(-10**18)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 511ns -> 504ns (1.39% faster)

# Large Scale Test Cases

def test_max_num_many_objects():
    """Test that the function is robust and performant with many objects."""
    checker = InlineModelAdminChecks()
    # Mix of valid and invalid max_num values
    objs = [DummyObj(i) for i in range(500)] + [DummyObj(str(i)) for i in range(500)]
    # First 500 should pass, next 500 should fail
    for i, obj in enumerate(objs):
        codeflash_output = checker._check_max_num(obj); result = codeflash_output # 501μs -> 430μs (16.6% faster)
        if i < 500:
            pass
        else:
            pass

def test_max_num_all_none_large_scale():
    """Test that the function handles a large number of None values efficiently."""
    checker = InlineModelAdminChecks()
    objs = [DummyObj(None) for _ in range(1000)]
    for obj in objs:
        codeflash_output = checker._check_max_num(obj); result = codeflash_output # 129μs -> 133μs (3.08% slower)

def test_max_num_all_int_large_scale():
    """Test that the function handles a large number of integer values efficiently."""
    checker = InlineModelAdminChecks()
    objs = [DummyObj(i) for i in range(1000)]
    for obj in objs:
        codeflash_output = checker._check_max_num(obj); result = codeflash_output # 146μs -> 148μs (1.39% slower)

def test_max_num_all_invalid_large_scale():
    """Test that the function handles a large number of invalid values efficiently."""
    checker = InlineModelAdminChecks()
    objs = [DummyObj(str(i)) for i in range(1000)]
    for obj in objs:
        codeflash_output = checker._check_max_num(obj); result = codeflash_output # 847μs -> 704μs (20.3% faster)

# Additional Edge Case: Test with subclasses of int

def test_max_num_int_subclass_returns_empty_list():
    """Test that an int subclass is accepted as integer."""
    class MyInt(int): pass
    obj = DummyObj(MyInt(42))
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 536ns -> 3.01μs (82.2% slower)

# Additional Edge Case: Test with bool (Python treats bool as int)
def test_max_num_false_returns_empty_list():
    """Test that False is accepted as integer."""
    obj = DummyObj(False)
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 464ns -> 2.33μs (80.0% slower)

# Additional Edge Case: Test with bytes
def test_max_num_bytes_returns_error():
    """Test that bytes value for max_num returns an error."""
    obj = DummyObj(b'123')
    checker = InlineModelAdminChecks()
    codeflash_output = checker._check_max_num(obj); result = codeflash_output # 3.52μs -> 2.19μs (60.7% 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-InlineModelAdminChecks._check_max_num-mhd132ii and push.