⚡️ Speed up function deprecated by 171%

[codeflash-ai]

📄 171% (1.71x) speedup for deprecated in panel/util/warnings.py

⏱️ Runtime : 40.7 milliseconds → 15.0 milliseconds (best of 56 runs)

📝 Explanation and details

The optimized code achieves a 170% speedup through two key optimizations:

1. Cached Version Parsing with @lru_cache
The most significant optimization introduces _cached_version() with LRU caching for Version() object creation. In the original code, every call to deprecated() creates new Version objects for:

• current_version from __version__
• base_version from current_version.base_version
• remove_version and warn_version when they're strings

The profiler shows dramatic improvements in version parsing lines:

• current_version = Version(__version__): 34.9ms → 0.49ms (98% faster)
• base_version = Version(...): 25.7ms → 5.6ms (78% faster)
• remove_version = Version(...): 20.2ms → 1.1ms (95% faster)

Since __version__ and current_version.base_version are constants that repeat across all calls, caching eliminates redundant parsing entirely.

2. Optimized String Formatting
The original code built messages inefficiently by creating a base string then conditionally modifying it with slice operations (message[:-1]). The optimized version uses direct conditional formatting:

# Before: Build base, then modify
message = f"{old!r} is deprecated..."
if new:
    message = f"{message[:-1]}, use {new!r} instead."

# After: Build final message directly  
if new:
    message = f"{old!r} is deprecated..., use {new!r} instead."
else:
    message = f"{old!r} is deprecated..."

Performance Benefits by Test Case:

• Basic deprecation calls: ~100-105% speedup
• Cases with version object inputs: ~69% speedup (less caching benefit)
• Early returns due to warn_version: ~332% speedup (avoids most version parsing)
• Large-scale tests with many calls: Maintain consistent ~100% speedup

The caching particularly excels when deprecated() is called repeatedly with the same version strings, making it ideal for applications with frequent deprecation warnings.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import warnings

# imports
import pytest
from packaging.version import Version
from panel.util.warnings import deprecated


# function to test
# (PASTED CODE FROM panel/util/warnings.py, with minimal stubs for dependencies)
class PanelDeprecationWarning(Warning):
    pass

# Patch for __version__ import in deprecated
__version__ = "1.2.3"
from panel.util.warnings import deprecated

# unit tests

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

def test_deprecated_warns_basic():
    # Should warn with correct message and category when only required args are given
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("2.0.0", "foo") # 61.9μs -> 30.2μs (105% faster)

def test_deprecated_warns_with_new():
    # Should mention the new replacement if provided
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("2.0.0", "foo", "bar") # 55.6μs -> 27.6μs (101% faster)

def test_deprecated_warns_with_extra():
    # Should append extra message if provided
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("2.0.0", "foo", extra="See docs.") # 55.4μs -> 27.4μs (103% faster)

def test_deprecated_warns_with_new_and_extra():
    # Should include both new and extra in the message
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("2.0.0", "foo", "bar", extra="Please migrate soon.") # 54.3μs -> 27.2μs (100% faster)
        msg = str(w[0].message)

def test_deprecated_accepts_version_objects():
    # Accepts Version objects as remove_version and warn_version
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated(Version("2.0.0"), "foo", "bar") # 44.2μs -> 26.1μs (69.4% faster)

# ---- EDGE TEST CASES ----

def test_deprecated_warn_version_future():
    # Should not warn if warn_version is in the future
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("2.0.0", "foo", warn_version="9.9.9") # 33.8μs -> 7.83μs (332% faster)

def test_deprecated_warn_version_now():
    # Should warn if warn_version is now
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("2.0.0", "foo", warn_version="1.2.3") # 57.5μs -> 29.0μs (98.1% faster)

def test_deprecated_warn_version_past():
    # Should warn if warn_version is in the past
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("2.0.0", "foo", warn_version="1.0.0") # 57.6μs -> 27.7μs (108% faster)



def test_deprecated_remove_version_future_warns():
    # Should warn if remove_version > current version
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("1.2.4", "foo") # 63.1μs -> 31.7μs (98.8% faster)

def test_deprecated_extra_whitespace_stripped():
    # Should strip whitespace from extra
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("2.0.0", "foo", extra="  extra info   ") # 56.7μs -> 28.3μs (100% faster)

def test_deprecated_new_and_extra_empty():
    # Should not fail if new or extra are empty strings
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("2.0.0", "foo", new="", extra="") # 54.5μs -> 26.7μs (104% faster)

def test_deprecated_old_is_empty_string():
    # Should handle empty string as old
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("2.0.0", "") # 53.7μs -> 26.4μs (103% faster)

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

def test_deprecated_large_number_of_calls():
    # Should not leak warnings or raise errors on many calls with different names
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        for i in range(100):
            deprecated("2.0.0", f"foo{i}", f"bar{i}", extra=f"extra{i}")
        for i in range(100):
            msg = str(w[i].message)

def test_deprecated_large_version_strings():
    # Should handle very large version numbers
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("123.456.789", "foo") # 52.7μs -> 25.4μs (108% faster)

def test_deprecated_long_strings():
    # Should handle very long strings for old, new, and extra
    long_old = "o" * 500
    long_new = "n" * 500
    long_extra = "e" * 500
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        deprecated("2.0.0", long_old, long_new, extra=long_extra) # 55.0μs -> 27.4μs (101% faster)
        msg = str(w[0].message)

def test_deprecated_many_unique_versions():
    # Should handle many unique remove_versions
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        for i in range(50):
            v = f"2.0.{i}"
            deprecated(v, f"foo{i}")
        for i in range(50):
            pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import warnings

# imports
import pytest  # used for our unit tests
from packaging.version import Version
from panel.util.warnings import deprecated


class PanelDeprecationWarning(Warning):
    pass
from panel.util.warnings import deprecated


# Helper to set the simulated __version__ for each test
def set_test_version(version):
    deprecated.__test_version__ = version

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


















def test_many_deprecations_in_loop():
    """Test calling deprecated many times in succession (performance/robustness)."""
    set_test_version("1.2.3")
    # We'll call deprecated 500 times and check that all warnings are emitted
    N = 500
    with warnings.catch_warnings(record=True) as wlist:
        warnings.simplefilter("always")
        for i in range(N):
            deprecated("2.0.0", f"foo{i}")
    for i in range(N):
        pass



def test_large_number_of_unique_warnings():
    """Test that deprecated emits unique warnings for different 'old' values."""
    set_test_version("1.2.3")
    N = 1000
    with warnings.catch_warnings(record=True) as wlist:
        warnings.simplefilter("always")
        for i in range(N):
            deprecated("2.0.0", f"foo_{i}")
    seen = set()
    for w in wlist:
        msg = str(w.message)
        seen.add(msg)
# 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.warnings import deprecated
import pytest

def test_deprecated():
    with pytest.raises(InvalidVersion, match="Invalid\\ version:\\ ''"):
        deprecated('', '', new='', extra='', warn_version='')

def test_deprecated_2():
    with pytest.raises(InvalidVersion, match="Invalid\\ version:\\ 'V'"):
        deprecated('', '', new='', extra='', warn_version='V')

To edit these changes git checkout codeflash/optimize-deprecated-mhbxd634 and push.