⚡️ Speed up function base_version by 91%

[codeflash-ai]

📄 91% (0.91x) speedup for base_version in panel/util/__init__.py

⏱️ Runtime : 3.53 milliseconds → 1.84 milliseconds (best of 52 runs)

📝 Explanation and details

The key optimization is pre-compiling the regex pattern at module import time instead of recompiling it on every function call.

What changed:

• Moved re.compile(r"([\d]+\.[\d]+\.[\d]+(?:a|rc|b)?[\d]*)") to module level as _pattern
• Changed re.match(pattern, version) to _pattern.match(version)

Why this is faster:
In the original code, re.match() internally compiles the regex pattern string every time the function is called. This compilation involves parsing the pattern, building a finite state automaton, and optimizing it - expensive operations that were happening 5,273 times in the profiler results.

The optimized version compiles the pattern once at import time and reuses the compiled pattern object. The line profiler shows the dramatic impact:

• Original: re.match(pattern, version) took 10.1ms (75.3% of total time)
• Optimized: _pattern.match(version) took only 2.8ms (54.5% of total time)

Performance characteristics:

• 91% speedup overall (3.53ms → 1.84ms)
• Most effective for repeated calls - the more times base_version() is called, the greater the benefit
• Large-scale test cases show the biggest improvements (79-137% faster) because they call the function many times
• Even single calls benefit (30-120% faster) since regex compilation overhead is eliminated
• Non-matching patterns see huge gains (89-157% faster) because they avoid the expensive compilation step entirely

This is a classic example of moving expensive computation from runtime to import time, which is particularly beneficial for utility functions that may be called frequently.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import re

# imports
import pytest  # used for our unit tests
from panel.util.__init__ import base_version

# unit tests

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

def test_basic_release_version():
    # Basic release version, should be returned unchanged
    codeflash_output = base_version("1.2.3") # 4.67μs -> 2.63μs (77.1% faster)

def test_basic_alpha_version():
    # Alpha pre-release
    codeflash_output = base_version("1.2.3a1") # 3.80μs -> 2.27μs (67.3% faster)

def test_basic_beta_version():
    # Beta pre-release
    codeflash_output = base_version("1.2.3b2") # 3.67μs -> 2.19μs (67.7% faster)

def test_basic_rc_version():
    # Release candidate pre-release
    codeflash_output = base_version("1.2.3rc3") # 3.66μs -> 2.21μs (65.7% faster)

def test_basic_with_extra_suffix():
    # Version with additional post-release and local version suffix
    codeflash_output = base_version("1.2.3.post4+g0695e214") # 3.61μs -> 2.17μs (65.9% faster)

def test_basic_with_pre_and_post_suffix():
    # Version with pre-release and post-release suffix
    codeflash_output = base_version("1.2.3rc1.post2") # 3.57μs -> 2.27μs (57.4% faster)

def test_basic_with_pre_and_local_suffix():
    # Version with pre-release and local version suffix
    codeflash_output = base_version("1.2.3a19+abc123") # 3.55μs -> 2.17μs (63.3% faster)

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

def test_edge_non_pep440_version():
    # Non-PEP440 version string should be returned unchanged
    codeflash_output = base_version("foo-1.2.3") # 2.46μs -> 1.16μs (113% faster)
    codeflash_output = base_version("versionX") # 859ns -> 390ns (120% faster)
    codeflash_output = base_version("") # 540ns -> 285ns (89.5% faster)

def test_edge_partial_version():
    # Partial version, not matching pattern, should be returned unchanged
    codeflash_output = base_version("1.2") # 2.13μs -> 829ns (157% faster)
    codeflash_output = base_version("1") # 746ns -> 375ns (98.9% faster)
    codeflash_output = base_version("1.2.3.4") # 2.35μs -> 1.86μs (26.3% faster)

def test_edge_leading_and_trailing_spaces():
    # Leading/trailing spaces should prevent match, so returned unchanged
    codeflash_output = base_version(" 1.2.3") # 2.38μs -> 956ns (149% faster)
    codeflash_output = base_version("1.2.3 ") # 2.22μs -> 1.61μs (37.2% faster)

def test_edge_leading_v_character():
    # Leading 'v' is not matched, so returned unchanged
    codeflash_output = base_version("v1.2.3") # 2.43μs -> 1.04μs (134% faster)
    codeflash_output = base_version("v1.2.3rc1") # 852ns -> 394ns (116% faster)

def test_edge_leading_zeroes():
    # Leading zeroes in version components
    codeflash_output = base_version("01.02.003") # 3.88μs -> 2.24μs (72.7% faster)
    codeflash_output = base_version("01.02.003a1") # 1.27μs -> 980ns (30.1% faster)

def test_edge_multiple_numbers_in_suffix():
    # Suffix with multiple digits
    codeflash_output = base_version("1.2.3a123") # 3.31μs -> 2.04μs (62.1% faster)
    codeflash_output = base_version("1.2.3rc456") # 1.20μs -> 779ns (54.3% faster)
    codeflash_output = base_version("1.2.3b789") # 897ns -> 486ns (84.6% faster)

def test_edge_suffix_without_digits():
    # Pre-release without digits is not matched by the pattern
    codeflash_output = base_version("1.2.3a") # 3.39μs -> 1.98μs (71.3% faster)
    codeflash_output = base_version("1.2.3rc") # 1.25μs -> 694ns (80.3% faster)
    codeflash_output = base_version("1.2.3b") # 866ns -> 475ns (82.3% faster)

def test_edge_dot_in_suffix():
    # Suffix with dot (not matched, so returned unchanged)
    codeflash_output = base_version("1.2.3a1.post2") # 3.42μs -> 2.01μs (69.9% faster)
    codeflash_output = base_version("1.2.3rc1.dev5") # 1.18μs -> 739ns (59.5% faster)

def test_edge_long_version_string():
    # Very long version string with multiple segments
    codeflash_output = base_version("1.2.3rc1.post2.dev5+build123") # 3.20μs -> 1.96μs (63.4% faster)
    codeflash_output = base_version("1.2.3b10.post4+g0695e214") # 1.28μs -> 753ns (70.0% faster)

def test_edge_version_with_underscore():
    # Underscore in version, not matched, so returned unchanged
    codeflash_output = base_version("1_2_3") # 2.52μs -> 1.13μs (122% faster)
    codeflash_output = base_version("1_2_3a1") # 869ns -> 408ns (113% faster)

def test_edge_version_with_dash():
    # Dash in version, not matched, so returned unchanged
    codeflash_output = base_version("1-2-3") # 2.44μs -> 1.16μs (110% faster)
    codeflash_output = base_version("1-2-3rc1") # 804ns -> 415ns (93.7% faster)

def test_edge_multiple_versions_in_string():
    # String containing multiple versions, only the first at the start is matched
    codeflash_output = base_version("1.2.3 and 2.3.4") # 3.96μs -> 2.37μs (67.2% faster)
    codeflash_output = base_version("1.2.3rc1 and 2.3.4rc2") # 1.37μs -> 873ns (57.2% faster)
    # If not at the start, not matched
    codeflash_output = base_version("foo 1.2.3") # 685ns -> 381ns (79.8% faster)

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

def test_large_scale_many_versions():
    # Test a list of 1000 version strings for performance and correctness
    base_versions = [f"{i}.{i+1}.{i+2}" for i in range(1000)]
    # Add some pre-release suffixes
    base_versions += [f"{i}.{i+1}.{i+2}a{i}" for i in range(500, 1000)]
    # Add some post-release and local version suffixes
    full_versions = [v + ".post4+g0695e214" for v in base_versions]
    # All should return the base version (without suffix)
    for v, b in zip(full_versions, base_versions):
        codeflash_output = base_version(v) # 1.05ms -> 585μs (79.5% faster)

def test_large_scale_non_matching_versions():
    # Test a large number of non-matching version strings
    non_matching = [f"foo{i}" for i in range(1000)]
    for v in non_matching:
        codeflash_output = base_version(v) # 509μs -> 218μs (133% faster)

def test_large_scale_mixed_versions():
    # Test a mix of matching and non-matching version strings
    versions = []
    expected = []
    for i in range(500):
        # Matching version
        v = f"{i}.{i+1}.{i+2}b{i}"
        versions.append(v)
        expected.append(v)
        # Non-matching version
        v2 = f"foo{i}"
        versions.append(v2)
        expected.append(v2)
    for v, exp in zip(versions, expected):
        codeflash_output = base_version(v) # 611μs -> 310μs (97.1% faster)

def test_large_scale_edge_cases():
    # Test edge cases with large input strings
    long_version = "1.2.3" + ".post4" * 100 + "+g0695e214" * 100
    codeflash_output = base_version(long_version) # 4.03μs -> 2.53μs (59.5% faster)
    # Very long non-matching string
    long_non_matching = "foo" * 1000
    codeflash_output = base_version(long_non_matching) # 941ns -> 449ns (110% faster)

def test_large_scale_leading_zero_versions():
    # Test many versions with leading zeros
    for i in range(1000):
        v = f"{i:03}.{(i+1):03}.{(i+2):03}a{i}"
        codeflash_output = base_version(v) # 683μs -> 370μs (84.3% faster)
# 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

import re

# imports
import pytest  # used for our unit tests
from panel.util.__init__ import base_version

# unit tests

# --------------------------
# 1. BASIC TEST CASES
# --------------------------

def test_plain_release_version():
    # Standard three-component version
    codeflash_output = base_version("1.2.3") # 4.13μs -> 2.58μs (60.4% faster)

def test_alpha_version():
    # Alpha pre-release
    codeflash_output = base_version("1.2.3a1") # 3.73μs -> 2.30μs (62.2% faster)

def test_beta_version():
    # Beta pre-release
    codeflash_output = base_version("1.2.3b4") # 3.73μs -> 2.30μs (62.2% faster)

def test_rc_version():
    # Release candidate pre-release
    codeflash_output = base_version("1.2.3rc2") # 3.46μs -> 2.17μs (59.6% faster)

def test_version_with_post_and_local():
    # Version with post-release and local version
    codeflash_output = base_version("1.2.3.post4+g0695e214") # 3.67μs -> 2.24μs (63.9% faster)

def test_version_with_dev_and_local():
    # Version with dev and local version
    codeflash_output = base_version("1.2.3.dev5+abc123") # 3.59μs -> 2.10μs (70.9% faster)

def test_version_with_spaces():
    # Leading/trailing spaces should not match (since re.match doesn't strip)
    codeflash_output = base_version(" 1.2.3") # 2.37μs -> 1.13μs (110% faster)
    codeflash_output = base_version("1.2.3 ") # 2.09μs -> 1.61μs (29.7% faster)

def test_version_with_only_major_minor():
    # Not matching the 3-component pattern
    codeflash_output = base_version("1.2") # 2.17μs -> 882ns (145% faster)

def test_version_with_non_version_string():
    # Non-version string should be returned as is
    codeflash_output = base_version("not.a.version") # 2.34μs -> 1.19μs (95.6% faster)

# --------------------------
# 2. EDGE TEST CASES
# --------------------------

def test_empty_string():
    # Empty string should be returned as is
    codeflash_output = base_version("") # 2.27μs -> 921ns (147% faster)

def test_version_with_leading_v():
    # Leading 'v' is not matched by the pattern, so should return input
    codeflash_output = base_version("v1.2.3") # 2.53μs -> 1.20μs (111% faster)

def test_version_with_more_than_three_components():
    # Four-component version is not matched, should return input
    codeflash_output = base_version("1.2.3.4") # 3.78μs -> 2.50μs (51.3% faster)

def test_version_with_hyphen_separator():
    # Hyphen separator is not matched, should return input
    codeflash_output = base_version("1.2.3-rc1") # 3.56μs -> 2.27μs (56.9% faster)

def test_version_with_underscore_separator():
    # Underscore separator is not matched, should return input
    codeflash_output = base_version("1.2.3_rc1") # 3.67μs -> 2.16μs (69.9% faster)

def test_version_with_uppercase_pre_release():
    # Uppercase pre-release is not matched, should return input
    codeflash_output = base_version("1.2.3RC1") # 3.66μs -> 2.14μs (70.9% faster)

def test_version_with_multiple_dots_in_local():
    # Only the base version should be returned
    codeflash_output = base_version("1.2.3.post4.dev5+g0695e214.abc") # 3.39μs -> 2.08μs (62.7% faster)

def test_version_with_leading_zeros():
    # Should match and preserve leading zeros
    codeflash_output = base_version("01.02.003") # 3.52μs -> 2.16μs (62.9% faster)
    codeflash_output = base_version("01.02.003rc1") # 1.43μs -> 944ns (51.8% faster)

def test_version_with_zeroes_in_prerelease():
    # Should match and preserve
    codeflash_output = base_version("1.2.3a0") # 3.25μs -> 1.96μs (65.6% faster)
    codeflash_output = base_version("1.2.3b0") # 1.20μs -> 731ns (63.6% faster)
    codeflash_output = base_version("1.2.3rc0") # 837ns -> 429ns (95.1% faster)

def test_version_with_long_prerelease_number():
    # Should match and preserve long numbers
    codeflash_output = base_version("1.2.3rc123456") # 3.25μs -> 1.96μs (65.4% faster)

def test_version_with_no_digits():
    # Should return input as is
    codeflash_output = base_version("abc.def.ghi") # 2.26μs -> 1.09μs (108% faster)

def test_version_with_non_ascii_characters():
    # Should return input as is
    codeflash_output = base_version("1.2.3β") # 5.27μs -> 2.89μs (82.3% faster)

def test_version_with_trailing_text():
    # Should only match at the start
    codeflash_output = base_version("1.2.3rc1foo") # 3.71μs -> 2.21μs (67.8% faster)

def test_version_with_leading_text():
    # Should not match if not at start
    codeflash_output = base_version("foo1.2.3rc1") # 2.43μs -> 1.12μs (118% faster)

def test_version_with_multiple_versions_in_string():
    # Only matches at the start
    codeflash_output = base_version("1.2.3rc1 4.5.6b2") # 3.79μs -> 2.53μs (49.8% faster)

def test_version_with_large_numbers():
    # Should match and preserve large numbers
    codeflash_output = base_version("123456789.987654321.123456789rc42") # 3.65μs -> 2.30μs (58.7% faster)

# --------------------------
# 3. LARGE SCALE TEST CASES
# --------------------------

def test_many_versions_in_list():
    # Test a list of valid versions
    versions = [f"{i}.{i+1}.{i+2}" for i in range(100)]
    for v in versions:
        codeflash_output = base_version(v) # 71.6μs -> 38.2μs (87.6% faster)

def test_many_versions_with_prerelease():
    # Test a list of valid pre-release versions
    pre_types = ['a', 'b', 'rc']
    for i in range(100):
        for pre in pre_types:
            v = f"{i}.{i+1}.{i+2}{pre}{i}"
            codeflash_output = base_version(v)

def test_many_versions_with_post_and_local():
    # Test a list of versions with post-release and local identifiers
    for i in range(100):
        v = f"{i}.{i+1}.{i+2}a{i}.post{i}+g{str(i).zfill(8)}"
        expected = f"{i}.{i+1}.{i+2}a{i}"
        codeflash_output = base_version(v) # 74.7μs -> 40.6μs (84.3% faster)

def test_large_non_matching_inputs():
    # Test a large number of non-matching strings
    for i in range(100):
        s = f"notaversion{i}"
        codeflash_output = base_version(s) # 55.2μs -> 23.6μs (134% faster)

def test_large_scale_mixed_versions():
    # Mix of valid and invalid versions
    valid = [f"{i}.{i+1}.{i+2}b{i}" for i in range(50)]
    invalid = [f"foo{i}.bar" for i in range(50)]
    for v in valid:
        codeflash_output = base_version(v) # 38.8μs -> 21.4μs (81.1% faster)
    for v in invalid:
        codeflash_output = base_version(v) # 26.1μs -> 11.0μs (137% faster)

def test_performance_on_large_string():
    # Test performance on a very long string that does not match
    s = "a" * 1000
    codeflash_output = base_version(s) # 2.29μs -> 1.10μs (108% faster)

def test_performance_on_large_matching_string():
    # Test performance on a very long valid version string
    s = "123." * 333 + "123rc1"
    # Only the start should be matched
    expected = "123.123.123rc1"
    codeflash_output = base_version(s) # 3.87μs -> 2.42μs (60.1% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from panel.util.__init__ import base_version

def test_base_version():
    base_version('🯰.০.0')

def test_base_version_2():
    base_version('')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_kzgds56_/tmp4dd9w8lc/test_concolic_coverage.py::test_base_version	8.45μs	3.21μs	163%✅
codeflash_concolic_kzgds56_/tmp4dd9w8lc/test_concolic_coverage.py::test_base_version_2	2.38μs	965ns	147%✅

To edit these changes git checkout codeflash/optimize-base_version-mha4ezz9 and push.