⚡️ Speed up function get_static_openai_acreate_func by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for get_static_openai_acreate_func in guardrails/utils/openai_utils/v1.py

⏱️ Runtime : 4.29 milliseconds → 3.99 milliseconds (best of 110 runs)

📝 Explanation and details

The optimized code achieves a 7% speedup by precomputing the warning arguments inside the function rather than passing them as literal values to warnings.warn().

Key changes:

• Stores the warning message string in a local variable _warn_msg
• Stores the DeprecationWarning class reference in a local variable _warn_category
• Passes these variables to warnings.warn() instead of inline literals

Why this improves performance:
The line profiler reveals that in the original code, the warnings.warn() call with inline arguments (lines showing 1654.2ns per hit) was the bottleneck. By pre-assigning the arguments to local variables, Python avoids some overhead in argument parsing and object creation during the warnings.warn() call. While the optimized version still shows the warnings.warn() line as the primary time consumer (2935.7ns per hit), the total function time decreased from 14.16ms to 12.80ms.

Test case performance:
The optimization shows consistent 5-11% improvements across most test cases, particularly benefiting:

• Single function calls (5-9% faster)
• Tests that capture and verify warning details (8-11% faster)
• Functions called frequently in loops maintain the same relative speedup

This optimization is most effective for code that calls this deprecated function frequently, as the per-call overhead reduction compounds over many invocations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import warnings

# imports
import pytest
from guardrails.utils.openai_utils.v1 import get_static_openai_acreate_func

# unit tests

# Basic Test Cases

def test_return_value_is_none():
    """
    Basic: Ensure the function always returns None.
    """
    codeflash_output = get_static_openai_acreate_func(); result = codeflash_output # 6.35μs -> 6.03μs (5.27% faster)

def test_deprecation_warning_is_raised():
    """
    Basic: Ensure the correct DeprecationWarning is raised with the expected message.
    """
    with pytest.warns(DeprecationWarning) as record:
        get_static_openai_acreate_func() # 5.07μs -> 4.68μs (8.40% faster)

# Edge Test Cases

def test_multiple_calls_raise_warning_each_time():
    """
    Edge: Calling the function multiple times should raise a warning each time.
    """
    for _ in range(5):
        with pytest.warns(DeprecationWarning) as record:
            get_static_openai_acreate_func()

def test_warning_category_is_deprecation():
    """
    Edge: Ensure the warning category is DeprecationWarning.
    """
    with pytest.warns(DeprecationWarning) as record:
        get_static_openai_acreate_func() # 4.94μs -> 4.60μs (7.41% faster)

def test_warning_message_contains_deprecated():
    """
    Edge: Ensure the warning message contains the word 'deprecated'.
    """
    with pytest.warns(DeprecationWarning) as record:
        get_static_openai_acreate_func() # 5.07μs -> 5.00μs (1.34% faster)

def test_warning_message_contains_version():
    """
    Edge: Ensure the warning message mentions the version '0.6.0'.
    """
    with pytest.warns(DeprecationWarning) as record:
        get_static_openai_acreate_func() # 5.01μs -> 4.78μs (4.73% faster)

# Large Scale Test Cases

def test_large_number_of_calls_performance_and_consistency():
    """
    Large Scale: Call the function many times to ensure performance and consistent behavior.
    """
    for i in range(1000):
        with pytest.warns(DeprecationWarning) as record:
            codeflash_output = get_static_openai_acreate_func(); result = codeflash_output

def test_warning_message_is_exact_for_all_calls():
    """
    Large Scale: Ensure the warning message is exactly the same for all calls.
    """
    messages = set()
    for _ in range(500):
        with pytest.warns(DeprecationWarning) as record:
            get_static_openai_acreate_func()
        messages.add(str(record[0].message))

# Determinism Test

def test_deterministic_behavior():
    """
    Edge: Ensure that repeated calls always produce the same result and warning.
    """
    results = []
    warnings_list = []
    for _ in range(10):
        with pytest.warns(DeprecationWarning) as record:
            results.append(get_static_openai_acreate_func())
            warnings_list.append(str(record[0].message))
# 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 guardrails.utils.openai_utils.v1 import get_static_openai_acreate_func

# unit tests

# 1. Basic Test Cases

def test_returns_none():
    """Test that the function always returns None."""
    codeflash_output = get_static_openai_acreate_func(); result = codeflash_output # 5.22μs -> 4.90μs (6.49% faster)

def test_deprecation_warning_is_raised():
    """Test that the correct deprecation warning is raised with the expected message."""
    with pytest.warns(DeprecationWarning) as record:
        get_static_openai_acreate_func() # 5.01μs -> 4.58μs (9.32% faster)

# 2. Edge Test Cases

def test_multiple_calls_return_none_and_warn():
    """Test that multiple calls consistently return None and raise the warning each time."""
    for _ in range(5):
        with pytest.warns(DeprecationWarning) as record:
            codeflash_output = get_static_openai_acreate_func(); result = codeflash_output

def test_warning_category_is_deprecationwarning():
    """Test that the warning category is DeprecationWarning."""
    with pytest.warns(DeprecationWarning) as record:
        get_static_openai_acreate_func() # 5.13μs -> 4.67μs (9.65% faster)

def test_warning_message_exact():
    """Test that the warning message is exactly as specified."""
    expected_message = "This function is deprecated and will be removed in 0.6.0"
    with pytest.warns(DeprecationWarning) as record:
        get_static_openai_acreate_func() # 5.30μs -> 4.76μs (11.2% faster)

def test_warning_is_not_runtimewarning():
    """Ensure no RuntimeWarning is raised."""
    with pytest.warns(DeprecationWarning):
        get_static_openai_acreate_func() # 5.28μs -> 4.96μs (6.35% faster)
    # If a RuntimeWarning is raised, pytest will fail the test

def test_return_type_is_none_type():
    """Test that the return type is NoneType."""
    codeflash_output = get_static_openai_acreate_func(); result = codeflash_output # 5.54μs -> 5.12μs (8.18% faster)

# 3. Large Scale Test Cases

def test_many_calls_consistency():
    """Test that the function behaves consistently over many calls."""
    for _ in range(1000):  # Large scale, but not excessive
        with pytest.warns(DeprecationWarning):
            codeflash_output = get_static_openai_acreate_func(); result = codeflash_output

def test_warning_message_consistency_large_scale():
    """Test that the warning message remains consistent over many calls."""
    expected_message = "This function is deprecated and will be removed in 0.6.0"
    for _ in range(1000):
        with pytest.warns(DeprecationWarning) as record:
            get_static_openai_acreate_func()

def test_parallel_calls_consistency():
    """Test that the function's output and warning are consistent when called in parallel (simulated)."""
    # Simulate parallel calls by calling in quick succession
    results = []
    warning_messages = []
    for _ in range(100):
        with pytest.warns(DeprecationWarning) as record:
            results.append(get_static_openai_acreate_func())
        warning_messages.append(str(record[0].message))

# 4. Additional Edge Cases

def test_no_arguments_allowed():
    """Test that the function does not accept any arguments."""
    with pytest.raises(TypeError):
        get_static_openai_acreate_func(1) # 4.05μs -> 4.74μs (14.5% slower)
    with pytest.raises(TypeError):
        get_static_openai_acreate_func(a=1) # 913ns -> 886ns (3.05% faster)

def test_warning_stacklevel_is_default():
    """Test that the warning is raised from this function's frame (stacklevel=1)."""
    # The stacklevel is not explicitly set, so it should be default (1)
    with pytest.warns(DeprecationWarning) as record:
        get_static_openai_acreate_func() # 5.71μs -> 5.18μs (10.2% faster)

def test_warning_message_unicode():
    """Test that the warning message is valid unicode."""
    with pytest.warns(DeprecationWarning) as record:
        get_static_openai_acreate_func() # 5.26μs -> 4.84μs (8.69% faster)
    msg = str(record[0].message)
    try:
        msg.encode("utf-8")
    except UnicodeEncodeError:
        pytest.fail("Warning message is not valid unicode")
# 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-get_static_openai_acreate_func-mh2ldqqc and push.