⚡️ Speed up method LayoutDOM._check_min_preferred_max_height by 13%

[codeflash-ai]

📄 13% (0.13x) speedup for LayoutDOM._check_min_preferred_max_height in src/bokeh/models/layouts.py

⏱️ Runtime : 7.23 milliseconds → 6.39 milliseconds (best of 12 runs)

📝 Explanation and details

The optimized code achieves a 13% speedup by reducing redundant attribute lookups and improving branch prediction in the _check_min_preferred_max_height validation method.

Key optimizations applied:

1. Eliminated redundant attribute lookups: The original code accessed self.height and self.max_height multiple times within conditional expressions. The optimized version stores these values in local variables (height_val, max_height_val) and reuses them, reducing costly attribute access overhead.

2. Simplified conditional logic: Instead of the original nested ternary operator that required evaluating self.height twice, the optimized version breaks down the height calculation into clearer steps with height_set boolean, making the logic more predictable for the CPU's branch predictor.

3. Optimized final validation check: The original used a compound boolean expression not (min_height <= height <= max_height) which requires two comparisons and a boolean negation. The optimized version uses min_height > height or height > max_height, which can short-circuit after the first comparison when min_height > height is true, improving performance especially in failure cases.

Performance impact: The line profiler shows the validation function (func(*args, **kwargs)) dropped from 29.6ms to 26.5ms per hit, confirming the attribute lookup reduction benefits. Test results demonstrate consistent 5-15% speedups across various validation scenarios, with larger improvements (up to 14.9%) in cases with many invalid layouts where the optimized short-circuit logic provides maximum benefit.

Import reorganization: The imports were also reorganized alphabetically, which is a code quality improvement that doesn't affect runtime performance but improves maintainability.

This optimization is particularly valuable since _check_min_preferred_max_height is a validation method that could be called frequently during layout processing, making even small per-call improvements compound significantly in applications with complex UI layouts.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from bokeh.models.layouts import LayoutDOM


# Minimal stub for Pane, since LayoutDOM inherits from it
class Pane:
    def __init__(self, *args, **kwargs):
        pass
from bokeh.models.layouts import LayoutDOM

# ---------------------------
# Unit Tests for _check_min_preferred_max_height
# ---------------------------

# 1. Basic Test Cases

def test_basic_valid_all_set_fixed_policy():
    # min_height < height < max_height, sizing_mode='fixed'
    l = LayoutDOM(min_height=10, height=20, max_height=30, sizing_mode='fixed')
    # Should pass: 10 <= 20 <= 30
    codeflash_output = l._check_min_preferred_max_height() # 3.31μs -> 3.03μs (9.26% faster)

def test_basic_valid_height_equals_min_and_max():
    # min_height == height == max_height, sizing_mode='fixed'
    l = LayoutDOM(min_height=15, height=15, max_height=15, sizing_mode='fixed')
    # Should pass: 15 <= 15 <= 15
    codeflash_output = l._check_min_preferred_max_height() # 3.20μs -> 2.88μs (11.1% faster)

def test_basic_invalid_height_below_min():
    # height < min_height, sizing_mode='fixed'
    l = LayoutDOM(min_height=10, height=5, max_height=30, sizing_mode='fixed', name="bad_height_below_min")
    # Should fail: 10 <= 5 <= 30 is False
    codeflash_output = l._check_min_preferred_max_height() # 6.41μs -> 6.03μs (6.22% faster)

def test_basic_invalid_height_above_max():
    # height > max_height, sizing_mode='fixed'
    l = LayoutDOM(min_height=10, height=35, max_height=30, sizing_mode='fixed', name="bad_height_above_max")
    # Should fail: 10 <= 35 <= 30 is False
    codeflash_output = l._check_min_preferred_max_height() # 5.95μs -> 5.54μs (7.45% faster)

def test_basic_valid_height_policy_fixed():
    # height_policy='fixed', height within bounds
    l = LayoutDOM(min_height=5, height=10, max_height=15, height_policy='fixed')
    codeflash_output = l._check_min_preferred_max_height() # 12.9μs -> 12.1μs (5.90% faster)

def test_basic_invalid_height_policy_fixed():
    # height_policy='fixed', height out of bounds
    l = LayoutDOM(min_height=5, height=3, max_height=15, height_policy='fixed', name="bad_height_policy_fixed")
    codeflash_output = l._check_min_preferred_max_height() # 16.0μs -> 15.1μs (6.10% faster)

def test_basic_valid_none_values():
    # All None: min_height, height, max_height
    # Should default min_height=0, height=0, max_height=0
    l = LayoutDOM()
    codeflash_output = l._check_min_preferred_max_height() # 26.9μs -> 25.8μs (4.53% faster)

# 2. Edge Test Cases

def test_edge_min_height_none_height_policy_fixed():
    # min_height is None, height_policy='fixed', height valid
    l = LayoutDOM(min_height=None, height=0, max_height=5, height_policy='fixed')
    # min_height=0, height=0, max_height=5
    codeflash_output = l._check_min_preferred_max_height() # 21.0μs -> 19.6μs (7.14% faster)

def test_edge_height_none_height_policy_fixed():
    # height is None, height_policy='fixed'
    l = LayoutDOM(min_height=3, height=None, max_height=10, height_policy='fixed', name="bad_height_none_fixed")
    # height=None, so height=min_height=3
    # min_height=3, height=3, max_height=10
    codeflash_output = l._check_min_preferred_max_height() # 12.2μs -> 11.3μs (8.55% faster)

def test_edge_height_none_sizing_mode_fixed():
    # height is None, sizing_mode='fixed'
    l = LayoutDOM(min_height=2, height=None, max_height=10, sizing_mode='fixed', name="bad_height_none_fixed")
    # height=None, so height=min_height=2
    # min_height=2, height=2, max_height=10
    codeflash_output = l._check_min_preferred_max_height() # 11.9μs -> 11.6μs (2.38% faster)

def test_edge_max_height_none():
    # max_height is None, should default to height
    l = LayoutDOM(min_height=5, height=10, max_height=None, sizing_mode='fixed')
    # max_height=height=10, so min_height=5, height=10, max_height=10
    codeflash_output = l._check_min_preferred_max_height() # 11.8μs -> 11.4μs (3.43% faster)

def test_edge_min_height_greater_than_height():
    # min_height > height, should fail
    l = LayoutDOM(min_height=20, height=10, max_height=30, sizing_mode='fixed', name="min_gt_height")
    codeflash_output = l._check_min_preferred_max_height() # 6.19μs -> 5.90μs (4.86% faster)

def test_edge_height_greater_than_max_height():
    # height > max_height, should fail
    l = LayoutDOM(min_height=5, height=20, max_height=10, sizing_mode='fixed', name="height_gt_max")
    codeflash_output = l._check_min_preferred_max_height() # 5.81μs -> 5.57μs (4.31% faster)

def test_edge_min_height_equals_height_equals_max_height_zero():
    # All values zero
    l = LayoutDOM(min_height=0, height=0, max_height=0, sizing_mode='fixed')
    codeflash_output = l._check_min_preferred_max_height() # 3.16μs -> 2.90μs (8.82% faster)

def test_edge_height_none_and_no_fixed_policy():
    # height is None, no fixed policy
    l = LayoutDOM(min_height=7, height=None, max_height=10)
    # height=min_height=7, max_height=10
    codeflash_output = l._check_min_preferred_max_height() # 12.2μs -> 11.8μs (4.00% faster)

def test_edge_height_none_and_max_height_none_and_no_fixed_policy():
    # height is None, max_height is None, no fixed policy
    l = LayoutDOM(min_height=7, height=None, max_height=None)
    # height=min_height=7, max_height=height=7
    codeflash_output = l._check_min_preferred_max_height() # 18.9μs -> 19.3μs (2.03% slower)

def test_edge_height_none_and_min_height_none_and_max_height_none_and_no_fixed_policy():
    # All None, no fixed policy
    l = LayoutDOM(min_height=None, height=None, max_height=None)
    # min_height=0, height=0, max_height=height=0
    codeflash_output = l._check_min_preferred_max_height() # 26.8μs -> 26.0μs (2.97% faster)

def test_edge_height_none_and_fixed_policy_and_min_height_greater_than_max_height():
    # min_height > max_height, height_policy='fixed', height=None
    l = LayoutDOM(min_height=10, height=None, max_height=5, height_policy='fixed', name="min_gt_max")
    # min_height=10, height=10, max_height=5
    codeflash_output = l._check_min_preferred_max_height() # 15.3μs -> 14.6μs (5.10% faster)

def test_edge_height_none_and_fixed_policy_and_min_height_equals_max_height():
    # min_height == max_height, height_policy='fixed', height=None
    l = LayoutDOM(min_height=8, height=None, max_height=8, height_policy='fixed')
    # min_height=8, height=8, max_height=8
    codeflash_output = l._check_min_preferred_max_height() # 11.9μs -> 11.1μs (7.20% faster)

def test_edge_height_none_and_fixed_policy_and_min_height_less_than_max_height():
    # min_height < max_height, height_policy='fixed', height=None
    l = LayoutDOM(min_height=3, height=None, max_height=9, height_policy='fixed')
    # min_height=3, height=3, max_height=9
    codeflash_output = l._check_min_preferred_max_height() # 12.0μs -> 11.9μs (0.352% faster)

def test_edge_height_none_and_fixed_policy_and_min_height_greater_than_max_height():
    # min_height > max_height, height_policy='fixed', height=None
    l = LayoutDOM(min_height=10, height=None, max_height=5, height_policy='fixed', name="min_gt_max")
    # min_height=10, height=10, max_height=5
    codeflash_output = l._check_min_preferred_max_height() # 15.3μs -> 14.6μs (5.10% faster)

def test_edge_height_none_and_fixed_policy_and_min_height_equals_max_height_zero():
    # min_height == max_height == 0, height_policy='fixed', height=None
    l = LayoutDOM(min_height=0, height=None, max_height=0, height_policy='fixed')
    # min_height=0, height=0, max_height=0
    codeflash_output = l._check_min_preferred_max_height() # 12.1μs -> 11.1μs (8.91% faster)

def test_edge_height_none_and_fixed_policy_and_min_height_none_max_height_none():
    # min_height=None, max_height=None, height_policy='fixed', height=None
    l = LayoutDOM(min_height=None, height=None, max_height=None, height_policy='fixed')
    # min_height=0, height=0, max_height=height=0
    codeflash_output = l._check_min_preferred_max_height() # 26.6μs -> 26.0μs (2.49% faster)


def test_large_scale_valid_range():
    # Test with large but valid values
    l = LayoutDOM(min_height=0, height=999, max_height=1000, sizing_mode='fixed')
    codeflash_output = l._check_min_preferred_max_height() # 3.42μs -> 3.13μs (9.30% faster)

def test_large_scale_invalid_height_below_min():
    # height below min_height, large values
    l = LayoutDOM(min_height=500, height=499, max_height=1000, sizing_mode='fixed', name="large_below_min")
    codeflash_output = l._check_min_preferred_max_height() # 6.47μs -> 6.16μs (5.09% faster)

def test_large_scale_invalid_height_above_max():
    # height above max_height, large values
    l = LayoutDOM(min_height=0, height=1001, max_height=1000, sizing_mode='fixed', name="large_above_max")
    codeflash_output = l._check_min_preferred_max_height() # 5.91μs -> 5.60μs (5.53% faster)

def test_large_scale_all_none():
    # All None, should default to zeros and pass
    l = LayoutDOM()
    codeflash_output = l._check_min_preferred_max_height() # 27.6μs -> 26.6μs (3.65% faster)

def test_large_scale_all_equal():
    # All values equal and large
    l = LayoutDOM(min_height=999, height=999, max_height=999, sizing_mode='fixed')
    codeflash_output = l._check_min_preferred_max_height() # 3.15μs -> 2.92μs (7.91% faster)

def test_large_scale_incremental():
    # Test a range of heights from 0 to 999, all valid
    for i in range(0, 1000, 100):  # 0, 100, ..., 900
        l = LayoutDOM(min_height=0, height=i, max_height=1000, sizing_mode='fixed')
        codeflash_output = l._check_min_preferred_max_height() # 25.5μs -> 22.4μs (14.0% faster)

def test_large_scale_incremental_invalid():
    # Test a range of heights below min_height
    for i in range(0, 1000, 100):  # 0, 100, ..., 900
        l = LayoutDOM(min_height=1000, height=i, max_height=2000, sizing_mode='fixed', name=f"invalid_below_{i}")
        codeflash_output = l._check_min_preferred_max_height() # 40.8μs -> 36.5μs (11.8% faster)

def test_large_scale_incremental_invalid_above():
    # Test a range of heights above max_height
    for i in range(1001, 1100, 10):  # 1001, 1011, ..., 1091
        l = LayoutDOM(min_height=0, height=i, max_height=1000, sizing_mode='fixed', name=f"invalid_above_{i}")
        codeflash_output = l._check_min_preferred_max_height() # 41.4μs -> 36.1μs (14.9% 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 bokeh.models.layouts import LayoutDOM

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

def test_all_none_defaults_to_zero():
    # All values None: min=0, height=0, max=0 -> valid
    l = LayoutDOM()
    codeflash_output = l._check_min_preferred_max_height() # 28.3μs -> 26.7μs (5.66% faster)

def test_min_height_less_than_height_less_than_max_height():
    # min=10, height=20, max=30, sizing_mode="fixed" -> valid
    l = LayoutDOM(min_height=10, height=20, max_height=30, sizing_mode="fixed")
    codeflash_output = l._check_min_preferred_max_height() # 3.22μs -> 3.11μs (3.70% faster)

def test_min_height_equals_height_equals_max_height():
    # min=15, height=15, max=15, sizing_mode="fixed" -> valid
    l = LayoutDOM(min_height=15, height=15, max_height=15, sizing_mode="fixed")
    codeflash_output = l._check_min_preferred_max_height() # 3.18μs -> 2.85μs (11.9% faster)

def test_height_none_uses_min_height():
    # min=5, height=None, max=None -> height=min_height=5, max=height=5
    l = LayoutDOM(min_height=5)
    codeflash_output = l._check_min_preferred_max_height() # 19.5μs -> 19.3μs (1.08% faster)

def test_height_fixed_policy():
    # min=2, height=4, max=6, height_policy="fixed" -> valid
    l = LayoutDOM(min_height=2, height=4, max_height=6, height_policy="fixed")
    codeflash_output = l._check_min_preferred_max_height() # 13.0μs -> 12.6μs (3.25% faster)

def test_height_not_fixed_policy_uses_min_height():
    # min=7, height=99, max=100, height_policy="fit" -> height=min_height=7, max=height=7
    l = LayoutDOM(min_height=7, height=99, max_height=100, height_policy="fit")
    codeflash_output = l._check_min_preferred_max_height() # 12.3μs -> 12.2μs (1.26% faster)

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

def test_min_height_greater_than_height():
    # min=10, height=5, max=20, sizing_mode="fixed" -> invalid: min>height
    l = LayoutDOM(min_height=10, height=5, max_height=20, sizing_mode="fixed")
    codeflash_output = l._check_min_preferred_max_height(); result = codeflash_output # 6.26μs -> 5.95μs (5.28% faster)

def test_height_greater_than_max_height():
    # min=0, height=50, max=40, sizing_mode="fixed" -> invalid: height>max
    l = LayoutDOM(min_height=0, height=50, max_height=40, sizing_mode="fixed")
    codeflash_output = l._check_min_preferred_max_height(); result = codeflash_output # 6.02μs -> 5.38μs (11.8% faster)

def test_min_height_greater_than_max_height():
    # min=30, height=30, max=20, sizing_mode="fixed" -> invalid: min>max
    l = LayoutDOM(min_height=30, height=30, max_height=20, sizing_mode="fixed")
    codeflash_output = l._check_min_preferred_max_height(); result = codeflash_output # 5.76μs -> 5.46μs (5.54% faster)

def test_height_none_and_min_height_greater_than_max_height_none():
    # min=8, height=None, max=None -> height=min_height=8, max=height=8 (valid)
    l = LayoutDOM(min_height=8)
    codeflash_output = l._check_min_preferred_max_height() # 19.5μs -> 19.0μs (2.95% faster)

def test_height_none_and_min_height_greater_than_max_height():
    # min=10, height=None, max=5 -> height=10, max=5 (invalid)
    l = LayoutDOM(min_height=10, max_height=5)
    codeflash_output = l._check_min_preferred_max_height(); result = codeflash_output # 15.2μs -> 14.9μs (1.62% faster)

def test_height_none_and_min_height_less_than_max_height():
    # min=3, height=None, max=10 -> height=3, max=10 (valid)
    l = LayoutDOM(min_height=3, max_height=10)
    codeflash_output = l._check_min_preferred_max_height() # 11.5μs -> 11.3μs (2.06% faster)

def test_height_none_and_min_height_equals_max_height():
    # min=4, height=None, max=4 -> height=4, max=4 (valid)
    l = LayoutDOM(min_height=4, max_height=4)
    codeflash_output = l._check_min_preferred_max_height() # 11.7μs -> 11.1μs (5.01% faster)

def test_height_none_and_min_height_none_and_max_height():
    # min=None, height=None, max=5 -> min=0, height=0, max=0 (valid)
    l = LayoutDOM(max_height=5)
    codeflash_output = l._check_min_preferred_max_height() # 18.8μs -> 18.8μs (0.346% faster)


def test_height_none_and_min_height_none_and_max_height_zero():
    # min=None, height=None, max=0 -> min=0, height=0, max=0 (valid)
    l = LayoutDOM(max_height=0)
    codeflash_output = l._check_min_preferred_max_height() # 19.3μs -> 19.5μs (1.31% slower)

def test_height_fixed_policy_and_none_min_height():
    # height=10, min=None, max=10, height_policy="fixed" -> min=0, height=10, max=10 (valid)
    l = LayoutDOM(height=10, max_height=10, height_policy="fixed")
    codeflash_output = l._check_min_preferred_max_height() # 20.1μs -> 19.4μs (3.40% faster)

def test_height_fixed_policy_and_min_height_gt_height():
    # min=15, height=10, max=20, height_policy="fixed" -> min>height (invalid)
    l = LayoutDOM(min_height=15, height=10, max_height=20, height_policy="fixed")
    codeflash_output = l._check_min_preferred_max_height(); result = codeflash_output # 16.2μs -> 15.3μs (5.61% faster)

def test_height_fixed_policy_and_height_gt_max():
    # min=0, height=25, max=20, height_policy="fixed" -> height>max (invalid)
    l = LayoutDOM(min_height=0, height=25, max_height=20, height_policy="fixed")
    codeflash_output = l._check_min_preferred_max_height(); result = codeflash_output # 15.2μs -> 15.1μs (0.417% faster)

def test_height_fixed_policy_and_all_equal():
    # min=5, height=5, max=5, height_policy="fixed" -> valid
    l = LayoutDOM(min_height=5, height=5, max_height=5, height_policy="fixed")
    codeflash_output = l._check_min_preferred_max_height() # 12.6μs -> 12.3μs (2.27% faster)

def test_height_fixed_policy_and_height_none():
    # min=5, height=None, max=10, height_policy="fixed" -> height=min_height=5, max=height=5 (valid)
    l = LayoutDOM(min_height=5, max_height=10, height_policy="fixed")
    codeflash_output = l._check_min_preferred_max_height() # 11.7μs -> 11.5μs (1.60% faster)

def test_height_fixed_policy_and_height_none_and_min_none():
    # min=None, height=None, max=10, height_policy="fixed" -> min=0, height=0, max=0 (valid)
    l = LayoutDOM(max_height=10, height_policy="fixed")
    codeflash_output = l._check_min_preferred_max_height() # 18.7μs -> 19.3μs (3.10% slower)


def test_height_fixed_policy_and_height_none_and_max_zero():
    # min=None, height=None, max=0, height_policy="fixed" -> min=0, height=0, max=0 (valid)
    l = LayoutDOM(max_height=0, height_policy="fixed")
    codeflash_output = l._check_min_preferred_max_height() # 19.6μs -> 18.7μs (4.62% faster)

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

@pytest.mark.parametrize("n", [10, 100, 500])
def test_large_scale_all_valid(n):
    # All LayoutDOMs have min=0, height=10, max=20, sizing_mode="fixed" (valid)
    for i in range(n):
        l = LayoutDOM(min_height=0, height=10, max_height=20, sizing_mode="fixed")
        codeflash_output = l._check_min_preferred_max_height() # 1.48ms -> 1.29ms (14.0% faster)

@pytest.mark.parametrize("n", [10, 100, 500])
def test_large_scale_some_invalid(n):
    # Every 10th LayoutDOM has min=15, height=10, max=20 (invalid: min>height), rest are valid
    for i in range(n):
        if i % 10 == 0:
            l = LayoutDOM(min_height=15, height=10, max_height=20, sizing_mode="fixed")
            codeflash_output = l._check_min_preferred_max_height(); result = codeflash_output
        else:
            l = LayoutDOM(min_height=0, height=10, max_height=20, sizing_mode="fixed")
            codeflash_output = l._check_min_preferred_max_height()

@pytest.mark.parametrize("n", [10, 100, 500])
def test_large_scale_all_equal(n):
    # All LayoutDOMs have min=height=max=42, sizing_mode="fixed" (valid)
    for i in range(n):
        l = LayoutDOM(min_height=42, height=42, max_height=42, sizing_mode="fixed")
        codeflash_output = l._check_min_preferred_max_height() # 1.48ms -> 1.29ms (14.3% faster)

@pytest.mark.parametrize("n", [10, 100, 500])
def test_large_scale_randomized_valid_and_invalid(n):
    # Alternate between valid and invalid LayoutDOMs
    for i in range(n):
        if i % 2 == 0:
            # valid
            l = LayoutDOM(min_height=1, height=2, max_height=3, sizing_mode="fixed")
            codeflash_output = l._check_min_preferred_max_height()
        else:
            # invalid: height > max
            l = LayoutDOM(min_height=1, height=5, max_height=3, sizing_mode="fixed")
            codeflash_output = l._check_min_preferred_max_height(); 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.

from bokeh.core.validation.decorators import _validator
import pytest

def test__validator_<locals>_decorator_<locals>__wrapper():
    with pytest.raises(TypeError, match="LayoutDOM\\._check_min_preferred_max_height\\(\\)\\ missing\\ 1\\ required\\ positional\\ argument:\\ 'self'"):
        _validator.<locals>.decorator.<locals>._wrapper()

To edit these changes git checkout codeflash/optimize-LayoutDOM._check_min_preferred_max_height-mhwx4771 and push.