⚡️ Speed up function __getattr__ by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for __getattr__ in quantecon/kalman.py

⏱️ Runtime : 1.50 milliseconds → 1.40 milliseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 7% speedup by making two key micro-optimizations to the __getattr__ function:

1. Direct comparison vs. membership check:

• Original: if name not in __all__ performs a linear search through the __all__ list
• Optimized: if name != 'Kalman' does a direct string comparison
• Since __all__ contains only one element ('Kalman'), the direct comparison eliminates the overhead of Python's in operator and list iteration

2. Static warning message:

• Original: Uses f-strings with f"Please use {name} from..." which requires string formatting on every call
• Optimized: Pre-constructs the warning message as a static string since name is always 'Kalman' in the valid code path
• Eliminates the overhead of f-string interpolation and variable substitution

Performance impact by test case:
The optimizations show consistent improvements across all test scenarios:

• Valid attribute access: 2-8% faster (most common case)
• Invalid attribute names: 9-29% faster due to the direct comparison short-circuiting faster
• Large-scale tests with 1000 calls: ~10% faster, demonstrating the cumulative benefit

Why this matters:
This is a deprecation module that gets called whenever legacy code accesses quantecon.kalman.Kalman. While each individual call saves only microseconds, the cumulative effect can be meaningful in codebases with frequent legacy imports. The optimizations are particularly effective because they target the most common operations (string comparison and warning generation) in a function that's likely called repeatedly during module imports and attribute access.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import types
# function to test (as provided)
# --- BEGIN: quantecon/kalman.py ---
import warnings
import warnings as _warnings
from types import SimpleNamespace as _SimpleNamespace

# imports
import pytest
from quantecon.kalman import __getattr__

# Simulate quantecon._kalman for testing
class DummyKalman:
    pass

_kalman = _SimpleNamespace(Kalman=DummyKalman)

__all__ = ['Kalman']

def __dir__():
    return __all__
from quantecon.kalman import __getattr__  # --- END: quantecon/kalman.py ---

# unit tests

# 1. Basic Test Cases

def test_getattr_valid_name_returns_object_and_warns():
    # Test that __getattr__ returns the correct object and emits a DeprecationWarning for valid attribute
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        codeflash_output = __getattr__('Kalman'); obj = codeflash_output # 1.62μs -> 1.58μs (2.65% faster)

def test_getattr_invalid_name_raises_attributeerror():
    # Test that __getattr__ raises AttributeError for an invalid attribute
    invalid_names = ['kalman', 'KALMAN', 'kalMan', '', 'NotAKalman', None, 123]
    for name in invalid_names:
        with pytest.raises(AttributeError) as excinfo:
            __getattr__(name)
        if isinstance(name, str):
            pass

def test_dir_returns_all():
    # Test that __dir__ returns the correct list of attributes
    result = __dir__()

# 2. Edge Test Cases

def test_getattr_case_sensitivity():
    # __all__ contains 'Kalman', so 'kalman' should not work (case sensitive)
    with pytest.raises(AttributeError):
        __getattr__('kalman') # 375ns -> 333ns (12.6% faster)

def test_getattr_with_non_string_types():
    # Non-string types should raise AttributeError (since not in __all__)
    for val in [None, 42, 3.14, True, object(), [], {}, ()]:
        with pytest.raises(AttributeError):
            __getattr__(val)

def test_getattr_with_similar_names():
    # Names similar to 'Kalman' but not exactly should fail
    for name in ['KalmanFilter', 'Kalman1', 'Kal man', 'Kalman ']:
        with pytest.raises(AttributeError):
            __getattr__(name)

def test_getattr_warning_stacklevel():
    # Check that the warning stacklevel is set to 2 (hard to check directly, but warning is raised)
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        __getattr__('Kalman') # 1.71μs -> 1.58μs (7.90% faster)
        # Stacklevel is not directly exposed, but this ensures warning is raised

def test_getattr_warning_message_exact():
    # The warning message should match the expected format exactly
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        __getattr__('Kalman') # 1.58μs -> 1.54μs (2.73% faster)
        msg = str(w[0].message)

# 3. Large Scale Test Cases

def test_getattr_performance_many_calls():
    # Make many calls to __getattr__ with valid attribute and check all return the same object
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        results = [__getattr__('Kalman') for _ in range(500)] # 1.08μs -> 1.04μs (3.93% faster)

def test_getattr_performance_many_invalid_calls():
    # Make many calls to __getattr__ with invalid attribute and check all raise AttributeError
    for i in range(500):
        with pytest.raises(AttributeError):
            __getattr__(f'Kalman{i}')

def test_dir_large_scale():
    # __dir__ should be fast and always return the same result, even if called many times
    for _ in range(500):
        result = __dir__()

# 4. Mutation Testing / Robustness

def test_getattr_mutation_wrong_warning_type():
    # If warning is not DeprecationWarning, test fails
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        __getattr__('Kalman') # 1.67μs -> 1.54μs (8.04% faster)

def test_getattr_mutation_wrong_return():
    # If __getattr__ returns the wrong object for 'Kalman', test fails
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        codeflash_output = __getattr__('Kalman'); result = codeflash_output # 1.04μs -> 1.00μs (4.20% faster)

def test_getattr_mutation_no_warning():
    # If __getattr__ does not warn for valid attribute, test fails
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        __getattr__('Kalman') # 1.62μs -> 1.54μs (5.45% faster)

def test_getattr_mutation_accepts_only_exact_all():
    # If __getattr__ accepts names not exactly in __all__, test fails
    with pytest.raises(AttributeError):
        __getattr__(' kalman') # 416ns -> 333ns (24.9% faster)
    with pytest.raises(AttributeError):
        __getattr__('Kalman ') # 250ns -> 250ns (0.000% faster)
    with pytest.raises(AttributeError):
        __getattr__('KALMAN') # 250ns -> 291ns (14.1% slower)
# 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
from quantecon.kalman import __getattr__

# function to test
# Copied from quantecon/kalman.py
__all__ = ['Kalman']

class DummyKalman:
    # Dummy class to simulate _kalman.Kalman
    pass

class DummyKalman2:
    # Used for mutation testing if needed
    pass

# Simulate the quantecon._kalman module for testing
class DummyModule:
    Kalman = DummyKalman

_kalman = DummyModule()

def __dir__():
    return __all__
from quantecon.kalman import __getattr__

# unit tests

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

def test_basic_existing_attribute_returns_object():
    """
    Test that __getattr__ returns the correct object for a valid attribute.
    """
    codeflash_output = __getattr__('Kalman'); obj = codeflash_output # 1.71μs -> 1.67μs (2.46% faster)

def test_basic_existing_attribute_warns_deprecation():
    """
    Test that __getattr__ emits a DeprecationWarning for valid attribute.
    """
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        codeflash_output = __getattr__('Kalman'); obj = codeflash_output # 1.54μs -> 1.54μs (0.000% faster)

def test_basic_dir_returns_all():
    """
    Test that __dir__ returns the correct __all__ list.
    """
    result = __dir__()

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

def test_edge_nonexistent_attribute_raises():
    """
    Test that __getattr__ raises AttributeError for an invalid attribute.
    """
    with pytest.raises(AttributeError) as excinfo:
        __getattr__('NotAKalman') # 375ns -> 333ns (12.6% faster)

def test_edge_empty_string_attribute_raises():
    """
    Test that __getattr__ raises AttributeError for empty string attribute.
    """
    with pytest.raises(AttributeError) as excinfo:
        __getattr__("") # 375ns -> 291ns (28.9% faster)

def test_edge_none_attribute_raises():
    """
    Test that __getattr__ raises AttributeError for None as attribute.
    """
    with pytest.raises(AttributeError) as excinfo:
        __getattr__(None) # 500ns -> 458ns (9.17% faster)

def test_edge_case_sensitive_attribute():
    """
    Test that __getattr__ is case sensitive (should not match 'kalman').
    """
    with pytest.raises(AttributeError):
        __getattr__('kalman') # 375ns -> 333ns (12.6% faster)

def test_edge_attribute_with_whitespace():
    """
    Test that __getattr__ does not match attributes with extra whitespace.
    """
    with pytest.raises(AttributeError):
        __getattr__(' Kalman') # 375ns -> 333ns (12.6% faster)
    with pytest.raises(AttributeError):
        __getattr__('Kalman ') # 250ns -> 250ns (0.000% faster)

def test_edge_attribute_with_special_characters():
    """
    Test that __getattr__ does not match attributes with special characters.
    """
    with pytest.raises(AttributeError):
        __getattr__('Kalman!') # 375ns -> 333ns (12.6% faster)
    with pytest.raises(AttributeError):
        __getattr__('Kalman@') # 250ns -> 250ns (0.000% faster)

def test_edge_attribute_type_enforcement():
    """
    Test that __getattr__ works only for string-like attribute names.
    """
    with pytest.raises(AttributeError):
        __getattr__(123) # 459ns -> 459ns (0.000% faster)
    with pytest.raises(AttributeError):
        __getattr__(object()) # 875ns -> 875ns (0.000% faster)

def test_edge_mutation_returns_correct_object():
    """
    Mutation test: If _kalman.Kalman changes, __getattr__ should return the new object.
    """
    # Swap out the Kalman attribute to a new class
    _kalman.Kalman = DummyKalman2
    codeflash_output = __getattr__('Kalman'); obj = codeflash_output # 1.75μs -> 1.71μs (2.46% faster)
    # Reset for other tests
    _kalman.Kalman = DummyKalman

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

def test_large_scale_many_invalid_attributes():
    """
    Test that __getattr__ consistently raises for many invalid attribute names.
    """
    for i in range(1000):  # Large number, but under the 1000 limit
        with pytest.raises(AttributeError):
            __getattr__(f'NotFound{i}')

def test_large_scale_many_valid_attribute_calls():
    """
    Test calling __getattr__ for the valid attribute many times.
    """
    for i in range(1000):
        codeflash_output = __getattr__('Kalman'); obj = codeflash_output # 1.05ms -> 954μs (9.81% faster)

def test_large_scale_performance_under_multiple_warnings():
    """
    Test that repeated calls to __getattr__ for valid attribute always warn.
    """
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        for i in range(100):
            codeflash_output = __getattr__('Kalman'); obj = codeflash_output
        for warning in w:
            pass

def test_large_scale_all_possible_attribute_names():
    """
    Test that __getattr__ only works for attributes in __all__ and fails for all others.
    """
    valid = set(__all__)
    # Generate a mix of valid and invalid attribute names
    names = ['Kalman', 'kalman', 'KalMan', 'KALMAN', 'Kalman ', ' Kalman', '', None]
    # Add some random names
    names += [f'NotFound{i}' for i in range(50)]
    for name in names:
        if name in valid:
            codeflash_output = __getattr__(name); obj = codeflash_output
        else:
            with pytest.raises(AttributeError):
                __getattr__(name)
# 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-__getattr__-mj9w9szt and push.