⚡️ Speed up method AmazonMistralConfig.get_config by 23%

[codeflash-ai]

📄 23% (0.23x) speedup for AmazonMistralConfig.get_config in litellm/llms/bedrock/chat/invoke_transformations/amazon_mistral_transformation.py

⏱️ Runtime : 2.23 milliseconds → 1.81 milliseconds (best of 481 runs)

📝 Explanation and details

The optimization achieves a 23% speedup through two key changes:

1. Eliminated expensive locals() usage in __init__:

• Replaced locals_.copy() and dictionary iteration with a direct tuple of parameter names and values
• This avoids creating and copying a dictionary containing all local variables, then filtering through them
• The explicit tuple approach (("max_tokens", max_tokens), ...) is much more efficient than dictionary operations

2. Optimized type checking in get_config:

• Changed isinstance(v, excluded_types) to type(v) not in excluded_types
• For exact type matching (which is the case here with built-in types like FunctionType), type() is significantly faster than isinstance() since it doesn't need to check inheritance chains
• Pre-computed the excluded types tuple outside the comprehension to avoid recreating it on each iteration

Performance characteristics:

• The optimizations are most effective when get_config is called frequently (shown in test cases with 500+ calls achieving 20%+ speedup)
• Benefits scale with the number of class attributes, as seen in tests with 500-900 dummy variables showing 40%+ improvements
• All test cases show consistent 10-20% improvements, indicating the optimizations help across different usage patterns

The changes preserve exact behavioral compatibility while eliminating unnecessary computational overhead in both initialization and configuration retrieval.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import types
from typing import List, Optional

# imports
import pytest
from litellm.llms.bedrock.chat.invoke_transformations.amazon_mistral_transformation import \
    AmazonMistralConfig


class BaseConfig:
    def __init__(self, **kwargs):
        pass

class BaseAWSLLM:
    def __init__(self, **kwargs):
        pass

class AmazonInvokeConfig(BaseConfig, BaseAWSLLM):
    def __init__(self, **kwargs):
        BaseConfig.__init__(self, **kwargs)
        BaseAWSLLM.__init__(self, **kwargs)
from litellm.llms.bedrock.chat.invoke_transformations.amazon_mistral_transformation import \
    AmazonMistralConfig

# ----------------- UNIT TESTS -----------------

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

def test_get_config_all_defaults():
    """
    Test get_config returns empty dict when all class attributes are None.
    """
    # Reset class variables to None for isolation
    AmazonMistralConfig.max_tokens = None
    AmazonMistralConfig.temperature = None
    AmazonMistralConfig.top_p = None
    AmazonMistralConfig.top_k = None
    AmazonMistralConfig.stop = None
    codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 5.45μs -> 4.91μs (11.0% faster)

def test_get_config_single_value():
    """
    Test get_config returns a dict with a single parameter set.
    """
    AmazonMistralConfig.max_tokens = 128
    AmazonMistralConfig.temperature = None
    AmazonMistralConfig.top_p = None
    AmazonMistralConfig.top_k = None
    AmazonMistralConfig.stop = None
    codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 5.06μs -> 4.37μs (16.0% faster)

def test_get_config_multiple_values():
    """
    Test get_config returns all set parameters.
    """
    AmazonMistralConfig.max_tokens = 256
    AmazonMistralConfig.temperature = 0.7
    AmazonMistralConfig.top_p = 0.85
    AmazonMistralConfig.top_k = None
    AmazonMistralConfig.stop = ["\n", "END"]
    codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 5.32μs -> 4.54μs (17.1% faster)
    expected = {
        'max_tokens': 256,
        'temperature': 0.7,
        'top_p': 0.85,
        'stop': ["\n", "END"]
    }

def test_get_config_after_init():
    """
    Test get_config reflects values set via __init__.
    """
    # Reset all to None first
    AmazonMistralConfig.max_tokens = None
    AmazonMistralConfig.temperature = None
    AmazonMistralConfig.top_p = None
    AmazonMistralConfig.top_k = None
    AmazonMistralConfig.stop = None
    # Set via __init__
    obj = AmazonMistralConfig(max_tokens=99, temperature=0.5)
    codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 5.09μs -> 4.36μs (16.7% faster)
    expected = {'max_tokens': 99, 'temperature': 0.5}

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

def test_get_config_zero_and_falsey_values():
    """
    Test get_config does not filter out 0 or empty list values (only None).
    """
    AmazonMistralConfig.max_tokens = 0
    AmazonMistralConfig.temperature = 0.0
    AmazonMistralConfig.top_p = None
    AmazonMistralConfig.top_k = 0.0
    AmazonMistralConfig.stop = []
    codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 5.18μs -> 4.66μs (11.1% faster)
    expected = {
        'max_tokens': 0,
        'temperature': 0.0,
        'top_k': 0.0,
        'stop': []
    }

def test_get_config_negative_and_large_values():
    """
    Test get_config with negative, very large, and unusual values.
    """
    AmazonMistralConfig.max_tokens = -10
    AmazonMistralConfig.temperature = 1e10
    AmazonMistralConfig.top_p = -0.5
    AmazonMistralConfig.top_k = 999999999
    AmazonMistralConfig.stop = ["", " "]
    codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 5.21μs -> 4.56μs (14.4% faster)
    expected = {
        'max_tokens': -10,
        'temperature': 1e10,
        'top_p': -0.5,
        'top_k': 999999999,
        'stop': ["", " "]
    }

def test_get_config_stop_sequences_with_special_characters():
    """
    Test get_config with stop sequences containing special/unicode characters.
    """
    AmazonMistralConfig.max_tokens = None
    AmazonMistralConfig.temperature = None
    AmazonMistralConfig.top_p = None
    AmazonMistralConfig.top_k = None
    AmazonMistralConfig.stop = ["\n", "\t", "💡", "END"]
    codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 5.01μs -> 4.48μs (11.8% faster)
    expected = {'stop': ["\n", "\t", "💡", "END"]}

def test_get_config_ignores_methods_and_private_attrs():
    """
    Ensure get_config does not include methods, classmethods, staticmethods, or private attributes.
    """
    # Add a fake method and private attribute
    AmazonMistralConfig._private = "should not show"
    def fake_method(self): pass
    AmazonMistralConfig.fake_method = fake_method
    AmazonMistralConfig.max_tokens = 123
    codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 5.78μs -> 5.04μs (14.8% faster)
    # Clean up
    delattr(AmazonMistralConfig, 'fake_method')
    delattr(AmazonMistralConfig, '_private')

def test_get_config_after_changing_class_variable():
    """
    Changing a class variable should immediately affect get_config.
    """
    AmazonMistralConfig.max_tokens = None
    codeflash_output = AmazonMistralConfig.get_config(); config1 = codeflash_output # 5.01μs -> 4.48μs (11.8% faster)
    AmazonMistralConfig.max_tokens = 42
    codeflash_output = AmazonMistralConfig.get_config(); config2 = codeflash_output # 3.69μs -> 3.18μs (16.0% faster)

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

def test_get_config_large_stop_list():
    """
    Test get_config with a large stop list (up to 1000 elements).
    """
    large_stop = [f"stop_{i}" for i in range(1000)]
    AmazonMistralConfig.max_tokens = 10
    AmazonMistralConfig.temperature = 0.9
    AmazonMistralConfig.top_p = 0.8
    AmazonMistralConfig.top_k = 50
    AmazonMistralConfig.stop = large_stop
    codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 5.20μs -> 4.53μs (14.9% faster)
    expected = {
        'max_tokens': 10,
        'temperature': 0.9,
        'top_p': 0.8,
        'top_k': 50,
        'stop': large_stop
    }

def test_get_config_many_changes():
    """
    Repeatedly change class variables and check get_config reflects the latest state.
    """
    for i in range(50):  # keep <1000 for speed
        AmazonMistralConfig.max_tokens = i
        AmazonMistralConfig.temperature = i / 100.0
        AmazonMistralConfig.top_p = None
        AmazonMistralConfig.top_k = None
        AmazonMistralConfig.stop = [str(i)]
        codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 170μs -> 138μs (23.0% faster)

def test_get_config_performance_large_number_of_calls():
    """
    Call get_config many times to ensure no performance degradation or memory leaks.
    """
    AmazonMistralConfig.max_tokens = 100
    AmazonMistralConfig.temperature = 0.1
    AmazonMistralConfig.top_p = 0.2
    AmazonMistralConfig.top_k = 0.3
    AmazonMistralConfig.stop = ["stop"]
    for _ in range(500):  # well under 1000
        codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 1.62ms -> 1.35ms (20.2% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import types
from typing import List, Optional

# imports
import pytest
from litellm.llms.bedrock.chat.invoke_transformations.amazon_mistral_transformation import \
    AmazonMistralConfig


# Function to test (self-contained version for testing)
class BaseConfig:
    def __init__(self, **kwargs):
        pass

class BaseAWSLLM:
    def __init__(self, **kwargs):
        pass

class AmazonInvokeConfig(BaseConfig, BaseAWSLLM):
    def __init__(self, **kwargs):
        BaseConfig.__init__(self, **kwargs)
        BaseAWSLLM.__init__(self, **kwargs)
from litellm.llms.bedrock.chat.invoke_transformations.amazon_mistral_transformation import \
    AmazonMistralConfig

# ---------------------- UNIT TESTS ----------------------

# 1. BASIC TEST CASES

def test_get_config_default_values():
    """
    Test that get_config returns an empty dict when all values are None (default).
    """
    # Ensure class variables are reset to None before test
    AmazonMistralConfig.max_tokens = None
    AmazonMistralConfig.temperature = None
    AmazonMistralConfig.top_p = None
    AmazonMistralConfig.top_k = None
    AmazonMistralConfig.stop = None
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 4.94μs -> 4.50μs (9.79% faster)

def test_get_config_one_value_set():
    """
    Test that get_config returns a dict with only the set value.
    """
    # Set only temperature
    AmazonMistralConfig.max_tokens = None
    AmazonMistralConfig.temperature = 0.5
    AmazonMistralConfig.top_p = None
    AmazonMistralConfig.top_k = None
    AmazonMistralConfig.stop = None
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 4.83μs -> 4.23μs (14.3% faster)
    # Reset
    AmazonMistralConfig.temperature = None

def test_get_config_multiple_values_set():
    """
    Test that get_config returns a dict with all set values.
    """
    AmazonMistralConfig.max_tokens = 100
    AmazonMistralConfig.temperature = 0.7
    AmazonMistralConfig.top_p = 0.9
    AmazonMistralConfig.top_k = None
    AmazonMistralConfig.stop = ["\n", "END"]
    expected = {
        "max_tokens": 100,
        "temperature": 0.7,
        "top_p": 0.9,
        "stop": ["\n", "END"]
    }
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 5.04μs -> 4.39μs (14.8% faster)
    # Reset
    AmazonMistralConfig.max_tokens = None
    AmazonMistralConfig.temperature = None
    AmazonMistralConfig.top_p = None
    AmazonMistralConfig.stop = None

def test_get_config_after_init_sets_class_vars():
    """
    Test that __init__ sets class variables and get_config reflects them.
    """
    # Reset all before
    AmazonMistralConfig.max_tokens = None
    AmazonMistralConfig.temperature = None
    AmazonMistralConfig.top_p = None
    AmazonMistralConfig.top_k = None
    AmazonMistralConfig.stop = None

    # Create instance with some values
    conf = AmazonMistralConfig(max_tokens=42, temperature=0.1, stop=["STOP"])
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 5.11μs -> 4.32μs (18.4% faster)
    # Reset
    AmazonMistralConfig.max_tokens = None
    AmazonMistralConfig.temperature = None
    AmazonMistralConfig.stop = None

# 2. EDGE TEST CASES

def test_get_config_with_empty_stop_list():
    """
    Test that an empty stop list is included in the config.
    """
    AmazonMistralConfig.max_tokens = None
    AmazonMistralConfig.temperature = None
    AmazonMistralConfig.top_p = None
    AmazonMistralConfig.top_k = None
    AmazonMistralConfig.stop = []
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 4.88μs -> 4.34μs (12.5% faster)
    AmazonMistralConfig.stop = None

def test_get_config_with_zero_and_falsey_values():
    """
    Test that zero values are included in the config.
    """
    AmazonMistralConfig.max_tokens = 0
    AmazonMistralConfig.temperature = 0.0
    AmazonMistralConfig.top_p = 0.0
    AmazonMistralConfig.top_k = 0.0
    AmazonMistralConfig.stop = None
    expected = {
        "max_tokens": 0,
        "temperature": 0.0,
        "top_p": 0.0,
        "top_k": 0.0,
    }
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 5.14μs -> 4.41μs (16.8% faster)
    # Reset
    AmazonMistralConfig.max_tokens = None
    AmazonMistralConfig.temperature = None
    AmazonMistralConfig.top_p = None
    AmazonMistralConfig.top_k = None

def test_get_config_with_special_characters_in_stop():
    """
    Test that stop sequences with special characters are handled.
    """
    special_stops = ["\n", "\t", "\r", "\u2603", "END"]
    AmazonMistralConfig.stop = special_stops
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 5.11μs -> 4.39μs (16.3% faster)
    AmazonMistralConfig.stop = None

def test_get_config_does_not_include_methods_or_private_attrs():
    """
    Test that get_config does not include methods or private attributes.
    """
    # Set some values
    AmazonMistralConfig.max_tokens = 1
    AmazonMistralConfig.temperature = 2.0
    codeflash_output = AmazonMistralConfig.get_config(); config = codeflash_output # 5.11μs -> 4.33μs (17.9% faster)
    # Should not include get_config, __init__, or any __xxx__ or _abcxxx
    for key in config:
        pass
    # Reset
    AmazonMistralConfig.max_tokens = None
    AmazonMistralConfig.temperature = None

def test_get_config_with_non_list_stop_raises():
    """
    Test that assigning a non-list to stop is included as-is (since there's no type enforcement),
    but the config should reflect the exact value.
    """
    AmazonMistralConfig.stop = "END"
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 5.02μs -> 4.44μs (13.1% faster)
    AmazonMistralConfig.stop = None

def test_get_config_with_unusual_types():
    """
    Test that get_config includes values of unusual types (e.g., dict, set).
    """
    AmazonMistralConfig.stop = {"a", "b"}
    AmazonMistralConfig.max_tokens = {"foo": 123}
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 5.00μs -> 4.45μs (12.6% faster)
    AmazonMistralConfig.stop = None
    AmazonMistralConfig.max_tokens = None

# 3. LARGE SCALE TEST CASES

def test_get_config_with_large_stop_list():
    """
    Test get_config with a large stop list (1000 elements).
    """
    stops = [str(i) for i in range(1000)]
    AmazonMistralConfig.stop = stops
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 5.04μs -> 4.42μs (13.8% faster)
    AmazonMistralConfig.stop = None

def test_get_config_with_many_class_variables():
    """
    Test get_config when many (<=1000) unrelated class variables are present.
    """
    # Dynamically add many dummy class variables
    for i in range(500):
        setattr(AmazonMistralConfig, f"dummy_{i}", i)
    AmazonMistralConfig.max_tokens = 123
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 118μs -> 83.6μs (41.6% faster)
    # All dummy_xxx and max_tokens should be present and not None
    for i in range(500):
        pass
    # Remove dummy variables after test
    for i in range(500):
        delattr(AmazonMistralConfig, f"dummy_{i}")
    AmazonMistralConfig.max_tokens = None

def test_get_config_performance_large_scale():
    """
    Test that get_config runs efficiently with many class variables (timing test).
    """
    import time

    # Add 900 dummy variables
    for i in range(900):
        setattr(AmazonMistralConfig, f"dummy_{i}", i)
    AmazonMistralConfig.temperature = 1.23
    start = time.time()
    codeflash_output = AmazonMistralConfig.get_config(); result = codeflash_output # 210μs -> 143μs (46.5% faster)
    elapsed = time.time() - start
    for i in range(900):
        pass
    # Cleanup
    for i in range(900):
        delattr(AmazonMistralConfig, f"dummy_{i}")
    AmazonMistralConfig.temperature = None
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from litellm.llms.bedrock.chat.invoke_transformations.amazon_mistral_transformation import AmazonMistralConfig

To edit these changes git checkout codeflash/optimize-AmazonMistralConfig.get_config-mhdnam9z and push.