⚡️ Speed up function check_python by 10%

[codeflash-ai]

📄 10% (0.10x) speedup for check_python in ultralytics/utils/checks.py

⏱️ Runtime : 6.01 milliseconds → 5.46 milliseconds (best of 59 runs)

📝 Explanation and details

The optimized code achieves a 10% speedup through several targeted micro-optimizations that reduce overhead in the version parsing loop:

Key Optimizations:

1. Pre-compiled Regex Pattern: The regex r"([^0-9]*)([\d.]+)" is now compiled once at module import time as _OP_VER_PATTERN instead of being recompiled on every iteration. This eliminates the expensive regex compilation overhead that was consuming 16.3% of execution time in the original code.

2. Reduced Function Lookup Overhead: The parse_version function is cached as a local variable parse_ver to avoid repeated global lookups during the loop iterations.

3. Pre-split Requirements: The required.strip(",").split(",") operation is moved outside the loop and stored in reqs, eliminating redundant string operations on each iteration.

4. Streamlined Conditional Logic: The operator comparison logic is restructured to use cleaner if/elif chains instead of compound boolean expressions, improving branch prediction and readability.

Performance Impact:

• The regex compilation overhead dropped from 16.3% to 4.4% of total execution time
• The optimization is particularly effective for scenarios with multiple version requirements (comma-separated ranges), as shown in test cases like test_python_version_many_calls() which saw an 11.6% improvement
• Single version checks see smaller but consistent gains (3-6% typical)

Why This Matters:
Version checking is a fundamental operation that likely occurs during package initialization, dependency validation, and compatibility checks throughout the codebase. Even modest per-call improvements compound significantly when called frequently, making this optimization valuable for application startup performance and runtime dependency validation.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

# function to test (copied and slightly adapted for testing, see notes below)
import re
import sys

# imports
import pytest
from ultralytics.utils.checks import check_python

# We'll simulate the current Python version as a string, as in ultralytics.utils.PYTHON_VERSION
PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"


# We'll simulate a LOGGER with a warning method for completeness
class DummyLogger:
    def __init__(self):
        self.last_warning = None

    def warning(self, msg):
        self.last_warning = msg


LOGGER = DummyLogger()

# ------------------------------------------
# unit tests for check_python
# ------------------------------------------


# Helper to get current python version as tuple
def get_current_py_tuple():
    return tuple(map(int, PYTHON_VERSION.split(".")))


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


def test_python_version_equal_minimum():
    """Test when current python version is exactly the minimum required version."""
    min_version = PYTHON_VERSION
    codeflash_output = check_python(minimum=min_version, hard=True)  # 11.1μs -> 10.8μs (3.06% faster)


def test_python_version_below_minimum_hard():
    """Test when current python version is below the minimum, hard=True (should raise)."""
    cur_tuple = get_current_py_tuple()
    min_version = f"{cur_tuple[0] + 1}.0.0"
    with pytest.raises(ModuleNotFoundError):
        check_python(minimum=min_version, hard=True)  # 9.66μs -> 9.21μs (4.89% faster)


def test_python_version_no_minimum():
    """Test when minimum version is None or empty string (should always pass)."""
    codeflash_output = check_python(minimum=None, hard=True)  # 1.19μs -> 1.18μs (0.764% faster)
    codeflash_output = check_python(minimum="", hard=True)  # 435ns -> 428ns (1.64% faster)


def test_python_version_nonstandard_version_strings():
    """Test non-standard version strings (e.g., with build tags)."""
    # Patch PYTHON_VERSION to a nonstandard string for this test
    orig_version = PYTHON_VERSION
    try:
        # Simulate a version like '3.10.12+cpu'
        monkey_version = orig_version + "+cpu"
        # Patch the global variable for this test
        globals()["PYTHON_VERSION"] = monkey_version
        cur_tuple = tuple(map(int, re.findall(r"\d+", monkey_version)[:3]))
        min_version = f"{cur_tuple[0]}.{cur_tuple[1]}.{cur_tuple[2]}"
        codeflash_output = check_python(minimum=min_version, hard=True)
    finally:
        globals()["PYTHON_VERSION"] = orig_version


def test_python_version_too_short_version():
    """Test when version string is too short (e.g., '3.10')."""
    orig_version = PYTHON_VERSION
    try:
        monkey_version = ".".join(orig_version.split(".")[:2])  # e.g., '3.10'
        globals()["PYTHON_VERSION"] = monkey_version
        # Should still work as parse_version will fill missing with 0
        min_version = monkey_version
        codeflash_output = check_python(minimum=min_version, hard=True)
    finally:
        globals()["PYTHON_VERSION"] = orig_version


def test_python_version_too_long_version():
    """Test when version string is longer than 3 parts (e.g., '3.10.12.1')."""
    orig_version = PYTHON_VERSION
    try:
        monkey_version = orig_version + ".1"
        globals()["PYTHON_VERSION"] = monkey_version
        min_version = ".".join(monkey_version.split(".")[:3])
        codeflash_output = check_python(minimum=min_version, hard=True)
    finally:
        globals()["PYTHON_VERSION"] = orig_version


def test_python_version_invalid_version(monkeypatch):
    """Test when PYTHON_VERSION is invalid (should not raise, should return True)."""
    orig_version = PYTHON_VERSION
    try:
        globals()["PYTHON_VERSION"] = "not.a.version"
        # Should fallback to (0,0,0) and fail if min > 0
        codeflash_output = check_python(minimum="0.0.0", hard=False)
        codeflash_output = check_python(minimum="0.0.1", hard=False)
    finally:
        globals()["PYTHON_VERSION"] = orig_version


def test_python_version_none_current(monkeypatch):
    """Test when PYTHON_VERSION is None (should always pass)."""
    orig_version = PYTHON_VERSION
    try:
        globals()["PYTHON_VERSION"] = None
        codeflash_output = check_python(minimum="3.0.0", hard=True)
    finally:
        globals()["PYTHON_VERSION"] = orig_version


def test_python_version_empty_current(monkeypatch):
    """Test when PYTHON_VERSION is empty string (should always pass)."""
    orig_version = PYTHON_VERSION
    try:
        globals()["PYTHON_VERSION"] = ""
        codeflash_output = check_python(minimum="3.0.0", hard=True)
    finally:
        globals()["PYTHON_VERSION"] = orig_version


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


@pytest.mark.parametrize("offset", range(0, 20))
def test_python_version_large_scale_many_versions(offset):
    """
    Test check_python with a large number of minimum versions in quick succession.
    Ensures no performance issues or leaks.
    """
    cur_tuple = get_current_py_tuple()
    # Simulate a range of minimum versions below current
    min_major = max(0, cur_tuple[0] - offset)
    min_minor = 0
    min_micro = 0
    min_version = f"{min_major}.{min_minor}.{min_micro}"
    # Should always pass as min_version <= current
    codeflash_output = check_python(minimum=min_version, hard=True)  # 148μs -> 140μs (5.51% faster)


def test_python_version_many_calls():
    """
    Call check_python 1000 times with valid minimums to check for performance/scalability.
    """
    cur_tuple = get_current_py_tuple()
    min_version = f"{max(0, cur_tuple[0] - 1)}.0.0"
    for _ in range(1000):
        codeflash_output = check_python(minimum=min_version, hard=True)  # 2.79ms -> 2.50ms (11.6% faster)


def test_python_version_many_failures():
    """
    Call check_python 1000 times with failing minimums to check for performance/scalability.
    """
    cur_tuple = get_current_py_tuple()
    min_version = f"{cur_tuple[0] + 1}.0.0"
    for _ in range(1000):
        codeflash_output = check_python(minimum=min_version, hard=False)  # 2.90ms -> 2.65ms (9.41% faster)


# ----------- ADDITIONAL EDGE CASES -------------


def test_python_version_with_spaces_in_minimum():
    """Test minimum version with extra spaces."""
    cur_tuple = get_current_py_tuple()
    min_version = f"  {cur_tuple[0]}.{cur_tuple[1]}.{cur_tuple[2]}  "
    codeflash_output = check_python(minimum=min_version.strip(), hard=True)  # 6.69μs -> 6.52μs (2.61% faster)


def test_python_version_with_comma_separated_ranges():
    """Test version range requirements (should pass for current version)."""
    cur_tuple = get_current_py_tuple()
    # Range: >=3.0.0,<4.0.0 (should pass for python3)
    min_version = ">=3.0.0,<4.0.0"
    codeflash_output = check_python(minimum=min_version, hard=True)  # 9.54μs -> 9.43μs (1.17% faster)


def test_python_version_with_inequality():
    """Test version with explicit inequality (should pass for current version)."""
    cur_tuple = get_current_py_tuple()
    min_version = f">={cur_tuple[0]}.{cur_tuple[1]}.{cur_tuple[2]}"
    codeflash_output = check_python(minimum=min_version, hard=True)  # 7.09μs -> 6.70μs (5.80% faster)


def test_python_version_with_exclusion():
    """Test version exclusion (should fail if current version is excluded)."""
    cur_tuple = get_current_py_tuple()
    min_version = f"=={cur_tuple[0]}.{cur_tuple[1]}.{cur_tuple[2]}"
    # Should pass for equality
    codeflash_output = check_python(minimum=min_version, hard=True)  # 7.08μs -> 6.64μs (6.58% faster)
    # Should fail for exclusion
    exclusion = f"!={cur_tuple[0]}.{cur_tuple[1]}.{cur_tuple[2]}"
    codeflash_output = check_python(minimum=exclusion, hard=False)  # 4.82μs -> 4.62μs (4.31% 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-check_python-mi8khpms and push.