⚡️ Speed up function validate_between_range by 16%

[codeflash-ai]

📄 16% (0.16x) speedup for validate_between_range in marimo/_plugins/validators.py

⏱️ Runtime : 2.36 milliseconds → 2.03 milliseconds (best of 95 runs)

📝 Explanation and details

The optimization achieves a 16% speedup by eliminating function call overhead through inlining the type check.

Key optimization:

• Inlined type validation: Instead of calling validate_number(value), the isinstance(value, (int, float)) check is performed directly within validate_between_range. The line profiler shows this function call was the bottleneck, consuming 74.7% of the original runtime.

Why this works:
Function calls in Python have significant overhead due to stack frame creation, argument passing, and return handling. By inlining a simple type check, we eliminate this overhead entirely. The profiling data confirms this - the original code spent 15.8ms on the validate_number call, while the optimized version performs the same check inline in just 2.0ms.

Performance characteristics:

• Best gains for valid inputs within range (20-30% faster) - these hit the hot path without exceptions
• Moderate gains for boundary violations (5-15% faster) - still benefit from avoiding the function call before raising exceptions
• Minimal impact for None values (~0-3%) - these return early and bypass most logic

The optimization maintains identical behavior and error messages while providing consistent speedups across all test scenarios, with the most dramatic improvements seen in high-frequency validation scenarios like the large-scale tests (21-23% faster).

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
_plugins/test_validators.py::test_validate_between_range	5.38μs	4.61μs	16.7%✅

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

from typing import Any

# imports
import pytest  # used for our unit tests
from marimo._plugins.validators import validate_between_range

# unit tests

# --- Basic Test Cases ---

def test_value_within_range():
    # Value is within min and max bounds
    validate_between_range(5, 1, 10) # 834ns -> 656ns (27.1% faster)

def test_value_equal_to_min():
    # Value is exactly at the lower bound
    validate_between_range(1, 1, 10) # 803ns -> 695ns (15.5% faster)

def test_value_equal_to_max():
    # Value is exactly at the upper bound
    validate_between_range(10, 1, 10) # 755ns -> 679ns (11.2% faster)

def test_value_none():
    # Value is None, should return without error
    validate_between_range(None, 1, 10) # 308ns -> 285ns (8.07% faster)

def test_min_value_none():
    # No lower bound
    validate_between_range(100, None, 200) # 825ns -> 651ns (26.7% faster)

def test_max_value_none():
    # No upper bound
    validate_between_range(-5, -10, None) # 710ns -> 640ns (10.9% faster)

def test_min_and_max_none():
    # No bounds at all
    validate_between_range(123, None, None) # 643ns -> 563ns (14.2% faster)

def test_float_value_within_range():
    # Float value within bounds
    validate_between_range(3.14, 1.0, 4.0) # 812ns -> 696ns (16.7% faster)

def test_int_and_float_mixed_types():
    # Mixed int/float types for bounds and value
    validate_between_range(5, 4.5, 5.5) # 919ns -> 785ns (17.1% faster)
    validate_between_range(5.0, 5, 6) # 533ns -> 451ns (18.2% faster)

# --- Edge Test Cases ---

def test_value_below_min():
    # Value is just below the lower bound
    with pytest.raises(ValueError) as excinfo:
        validate_between_range(0, 1, 10) # 1.36μs -> 1.19μs (14.1% faster)

def test_value_above_max():
    # Value is just above the upper bound
    with pytest.raises(ValueError) as excinfo:
        validate_between_range(11, 1, 10) # 1.38μs -> 1.32μs (4.30% faster)

def test_value_is_min_and_max():
    # min_value == max_value == value
    validate_between_range(7, 7, 7) # 759ns -> 658ns (15.3% faster)


def test_value_is_not_number():
    # Value is not a number, should raise TypeError
    with pytest.raises(TypeError):
        validate_between_range("abc", 1, 10) # 1.06μs -> 890ns (18.7% faster)
    with pytest.raises(TypeError):
        validate_between_range([1,2,3], 1, 10) # 607ns -> 448ns (35.5% faster)
    with pytest.raises(TypeError):
        validate_between_range({}, 1, 10) # 438ns -> 355ns (23.4% faster)

def test_min_and_max_are_none_and_value_is_none():
    # All None, should not raise
    validate_between_range(None, None, None) # 290ns -> 329ns (11.9% slower)

def test_min_and_max_are_none_and_value_is_not_number():
    # Value is not a number, should raise TypeError
    with pytest.raises(TypeError):
        validate_between_range("xyz", None, None) # 1.04μs -> 994ns (4.73% faster)


def test_value_is_inf():
    import math

    # Positive infinity above max
    with pytest.raises(ValueError):
        validate_between_range(math.inf, 1, 10) # 1.85μs -> 1.59μs (17.0% faster)
    # Negative infinity below min
    with pytest.raises(ValueError):
        validate_between_range(-math.inf, 1, 10) # 935ns -> 848ns (10.3% faster)

def test_min_and_max_are_equal_and_value_not_equal():
    # min_value == max_value, but value != min/max
    with pytest.raises(ValueError):
        validate_between_range(5, 7, 7) # 1.23μs -> 1.15μs (7.06% faster)
    with pytest.raises(ValueError):
        validate_between_range(9, 7, 7) # 791ns -> 725ns (9.10% faster)

def test_min_is_none_and_value_below_max():
    # Only max bound, value just below max
    validate_between_range(9, None, 10) # 727ns -> 643ns (13.1% faster)
    # Value above max
    with pytest.raises(ValueError):
        validate_between_range(11, None, 10) # 939ns -> 937ns (0.213% faster)

def test_max_is_none_and_value_above_min():
    # Only min bound, value just above min
    validate_between_range(6, 5, None) # 707ns -> 621ns (13.8% faster)
    # Value below min
    with pytest.raises(ValueError):
        validate_between_range(4, 5, None) # 928ns -> 875ns (6.06% faster)

def test_value_is_zero():
    # Zero as value, with negative and positive bounds
    validate_between_range(0, -1, 1) # 782ns -> 657ns (19.0% faster)

def test_value_is_negative():
    # Negative value, negative bounds
    validate_between_range(-5, -10, -1) # 826ns -> 696ns (18.7% faster)
    # Negative value below min
    with pytest.raises(ValueError):
        validate_between_range(-11, -10, -1) # 978ns -> 889ns (10.0% faster)

def test_value_is_float_edge():
    # Value is very close to min or max (floating point precision)
    validate_between_range(0.9999999999999999, 0.9999999999999998, 1.0) # 779ns -> 738ns (5.56% faster)
    with pytest.raises(ValueError):
        validate_between_range(0.9999999999999997, 0.9999999999999998, 1.0) # 3.04μs -> 2.90μs (4.80% faster)

# --- Large Scale Test Cases ---

def test_many_values_within_range():
    # Test a large number of values within range
    for i in range(0, 1000):  # 0..999
        validate_between_range(i, 0, 1000) # 219μs -> 181μs (21.1% faster)

def test_many_values_below_min():
    # Test a large number of values below min
    for i in range(-1000, 0):  # -1000..-1
        with pytest.raises(ValueError):
            validate_between_range(i, 0, 1000)

def test_many_values_above_max():
    # Test a large number of values above max
    for i in range(1001, 2000):  # 1001..1999
        with pytest.raises(ValueError):
            validate_between_range(i, 0, 1000)

def test_large_float_range():
    # Test with floats in a large range
    for i in range(1000):
        val = 0.1 * i  # 0.0, 0.1, ..., 99.9
        validate_between_range(val, 0.0, 100.0) # 237μs -> 194μs (22.2% faster)

def test_large_scale_all_none():
    # All values None in a large scale
    for _ in range(1000):
        validate_between_range(None, None, None) # 117μs -> 114μs (2.42% faster)

def test_large_scale_type_error():
    # Large scale type error checks
    for i in range(1000):
        with pytest.raises(TypeError):
            validate_between_range(str(i), 0, 1000)

# --- Determinism and Cleanliness ---

def test_determinism():
    # Same input always yields same result
    for _ in range(10):
        validate_between_range(42, 0, 100) # 3.79μs -> 2.88μs (31.5% faster)
        with pytest.raises(ValueError):
            validate_between_range(101, 0, 100)
        with pytest.raises(TypeError):
            validate_between_range("42", 0, 100)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

from typing import Any

# imports
import pytest  # used for our unit tests
from marimo._plugins.validators import validate_between_range

# unit tests

# --- Basic Test Cases ---

def test_value_within_range_int():
    # Value is within the range, should not raise
    validate_between_range(5, 1, 10) # 818ns -> 647ns (26.4% faster)

def test_value_within_range_float():
    # Value is within the range (float), should not raise
    validate_between_range(5.5, 1.0, 10.0) # 830ns -> 690ns (20.3% faster)

def test_value_equal_to_min():
    # Value equal to min_value, should not raise
    validate_between_range(1, 1, 10) # 814ns -> 644ns (26.4% faster)

def test_value_equal_to_max():
    # Value equal to max_value, should not raise
    validate_between_range(10, 1, 10) # 796ns -> 635ns (25.4% faster)

def test_value_none():
    # Value is None, should not raise (function returns early)
    validate_between_range(None, 1, 10) # 317ns -> 316ns (0.316% faster)

def test_min_value_none():
    # min_value is None, only max_value is checked
    validate_between_range(5, None, 10) # 828ns -> 600ns (38.0% faster)

def test_max_value_none():
    # max_value is None, only min_value is checked
    validate_between_range(5, 1, None) # 808ns -> 608ns (32.9% faster)

def test_both_bounds_none():
    # Both min_value and max_value are None, should not raise
    validate_between_range(5, None, None) # 697ns -> 532ns (31.0% faster)

# --- Edge Test Cases ---

def test_value_below_min():
    # Value is less than min_value, should raise ValueError
    with pytest.raises(ValueError) as excinfo:
        validate_between_range(0, 1, 10) # 1.31μs -> 1.18μs (11.4% faster)

def test_value_above_max():
    # Value is greater than max_value, should raise ValueError
    with pytest.raises(ValueError) as excinfo:
        validate_between_range(11, 1, 10) # 1.43μs -> 1.32μs (7.92% faster)

def test_value_equal_to_min_float():
    # Value equal to min_value (float), should not raise
    validate_between_range(1.0, 1.0, 10.0) # 808ns -> 730ns (10.7% faster)

def test_value_equal_to_max_float():
    # Value equal to max_value (float), should not raise
    validate_between_range(10.0, 1.0, 10.0) # 802ns -> 683ns (17.4% faster)

def test_value_below_min_float():
    # Value is less than min_value (float), should raise ValueError
    with pytest.raises(ValueError) as excinfo:
        validate_between_range(0.99, 1.0, 10.0) # 2.28μs -> 2.10μs (8.81% faster)

def test_value_above_max_float():
    # Value is greater than max_value (float), should raise ValueError
    with pytest.raises(ValueError) as excinfo:
        validate_between_range(10.01, 1.0, 10.0) # 2.16μs -> 1.97μs (9.75% faster)


def test_value_is_string():
    # Value is not a number, should raise TypeError
    with pytest.raises(TypeError) as excinfo:
        validate_between_range("5", 1, 10) # 1.47μs -> 1.13μs (30.1% faster)

def test_value_is_list():
    # Value is not a number, should raise TypeError
    with pytest.raises(TypeError) as excinfo:
        validate_between_range([5], 1, 10) # 1.08μs -> 919ns (17.8% faster)

def test_min_value_is_none_and_value_below_zero():
    # min_value is None, so negative values are allowed
    validate_between_range(-100, None, 10) # 813ns -> 678ns (19.9% faster)

def test_max_value_is_none_and_value_above_zero():
    # max_value is None, so large values are allowed
    validate_between_range(1000, 1, None) # 770ns -> 641ns (20.1% faster)

def test_min_and_max_are_none_and_value_extreme():
    # Both min and max are None, any number should be allowed
    validate_between_range(-1e100, None, None) # 851ns -> 646ns (31.7% faster)
    validate_between_range(1e100, None, None) # 377ns -> 285ns (32.3% faster)

def test_min_and_max_are_equal_and_value_equals():
    # min_value == max_value == value, should not raise
    validate_between_range(5, 5, 5) # 778ns -> 646ns (20.4% faster)

def test_min_and_max_are_equal_and_value_less():
    # min_value == max_value, value less, should raise
    with pytest.raises(ValueError):
        validate_between_range(4, 5, 5) # 1.33μs -> 1.25μs (6.29% faster)

def test_min_and_max_are_equal_and_value_greater():
    # min_value == max_value, value greater, should raise
    with pytest.raises(ValueError):
        validate_between_range(6, 5, 5) # 1.38μs -> 1.34μs (2.99% faster)


def test_value_is_inf():
    # Value is float('inf'), should raise ValueError for exceeding max_value
    with pytest.raises(ValueError):
        validate_between_range(float('inf'), 1, 10) # 1.96μs -> 1.59μs (22.9% faster)

def test_value_is_negative_inf():
    # Value is float('-inf'), should raise ValueError for being below min_value
    with pytest.raises(ValueError):
        validate_between_range(float('-inf'), 1, 10) # 1.38μs -> 1.31μs (5.89% faster)

# --- Large Scale Test Cases ---

def test_large_range_all_valid():
    # Test many values all within range, should not raise
    for i in range(0, 1000):
        validate_between_range(i, 0, 1000) # 222μs -> 181μs (22.3% faster)

def test_large_range_some_invalid_below():
    # Test many values, some below min_value
    for i in range(-10, 0):
        with pytest.raises(ValueError):
            validate_between_range(i, 0, 1000)

def test_large_range_some_invalid_above():
    # Test many values, some above max_value
    for i in range(1001, 1011):
        with pytest.raises(ValueError):
            validate_between_range(i, 0, 1000)

def test_large_float_range_valid():
    # Test many float values within range
    for i in range(0, 1000):
        validate_between_range(i + 0.5, 0.5, 1000.5) # 237μs -> 192μs (23.0% faster)

def test_large_float_range_invalid():
    # Test many float values just outside the range
    for i in range(-10, 0):
        with pytest.raises(ValueError):
            validate_between_range(i + 0.4, 0.5, 1000.5)
    for i in range(1001, 1011):
        with pytest.raises(ValueError):
            validate_between_range(i + 0.6, 0.5, 1000.5)

def test_large_none_values():
    # Test many None values, should not raise
    for _ in range(1000):
        validate_between_range(None, 0, 1000) # 116μs -> 113μs (3.04% faster)

def test_large_invalid_type_values():
    # Test many invalid types, should raise TypeError
    invalids = ["a", [], {}, set(), (1,), object()]
    for val in invalids:
        with pytest.raises(TypeError):
            validate_between_range(val, 0, 1000)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from marimo._plugins.validators import validate_between_range
import pytest

def test_validate_between_range():
    with pytest.raises(ValueError, match='Value\\ must\\ be\\ less\\ than\\ or\\ equal\\ to\\ 0'):
        validate_between_range(0.5, 0, 0)

def test_validate_between_range_2():
    with pytest.raises(ValueError, match='Value\\ must\\ be\\ greater\\ than\\ or\\ equal\\ to\\ 0'):
        validate_between_range(-1, 0, 0)

def test_validate_between_range_3():
    validate_between_range(0, 0, 0)

def test_validate_between_range_4():
    validate_between_range(0, 0, None)

def test_validate_between_range_5():
    validate_between_range(None, 0, 0)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_qdbuqf4z/tmp2kyjq4s3/test_concolic_coverage.py::test_validate_between_range	1.55μs	1.37μs	13.4%✅
codeflash_concolic_qdbuqf4z/tmp2kyjq4s3/test_concolic_coverage.py::test_validate_between_range_2	1.28μs	1.30μs	-1.54%⚠️
codeflash_concolic_qdbuqf4z/tmp2kyjq4s3/test_concolic_coverage.py::test_validate_between_range_3	835ns	674ns	23.9%✅
codeflash_concolic_qdbuqf4z/tmp2kyjq4s3/test_concolic_coverage.py::test_validate_between_range_4	726ns	655ns	10.8%✅
codeflash_concolic_qdbuqf4z/tmp2kyjq4s3/test_concolic_coverage.py::test_validate_between_range_5	297ns	344ns	-13.7%⚠️

To edit these changes git checkout codeflash/optimize-validate_between_range-mh5kip47 and push.