⚡️ Speed up function __getattr__ by 8%

[codeflash-ai]

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

⏱️ Runtime : 23.5 microseconds → 21.7 microseconds (best of 130 runs)

📝 Explanation and details

The optimization achieves a 7% speedup by eliminating unnecessary dynamic lookups in a deprecation wrapper module.

Key optimizations:

1. Direct string comparison: Changed if name not in __all__: to if name != 'nnash':. Since __all__ contains only one element ('nnash'), a direct string comparison is faster than checking membership in a list, avoiding the overhead of iterating through the container.

2. Direct attribute access: Replaced return getattr(_lqnash, name) with return _lqnash.nnash. Since we already validated that name == 'nnash', we can directly access the known attribute instead of using the slower getattr() function which performs dynamic attribute resolution.

3. Explicit __all__ definition: Added __all__ = ['nnash'] at module level to make the allowed attributes explicit and ensure consistent behavior.

Why this works: The original code used generic dynamic lookups suitable for multiple attributes, but since this deprecated module only exposes one attribute (nnash), we can use faster direct operations. String equality is faster than list membership, and direct attribute access bypasses Python's attribute resolution machinery.

Test case performance: The optimization shows consistent improvements across all test scenarios, with particularly strong gains for invalid attribute cases (10-21% faster) where the direct comparison quickly rejects invalid names without container iteration overhead.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import warnings

# imports
import pytest  # used for our unit tests
from quantecon.lqnash import __getattr__

# function to test
# This file is not meant for public use and will be removed v0.8.0.
# Use the `quantecon` namespace for importing the objects
# included below.

# We'll need to define a dummy _lqnash and nnash for testing purposes,
# since we can't actually import from quantecon in this environment.
# In a real test, you would use the actual quantecon._lqnash and nnash.

class DummyLQNash:
    def __init__(self):
        self.nnash = lambda x: x + 1  # Dummy function

_lqnash = DummyLQNash()
nnash = _lqnash.nnash

__all__ = ['nnash']

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

# unit tests

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

def test_basic_valid_attribute_returns_object_and_warns():
    # Test that requesting 'nnash' returns the correct object and raises a warning
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")  # Ensure all warnings are caught
        codeflash_output = __getattr__('nnash'); result = codeflash_output # 6.39μs -> 6.13μs (4.37% faster)

def test_basic_invalid_attribute_raises_attributeerror():
    # Test that requesting an invalid attribute raises AttributeError
    with pytest.raises(AttributeError) as excinfo:
        __getattr__('not_in_all') # 1.03μs -> 964ns (7.37% faster)

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

def test_edge_empty_string_attribute():
    # Test requesting an empty string as attribute
    with pytest.raises(AttributeError) as excinfo:
        __getattr__('') # 943ns -> 851ns (10.8% faster)


def test_edge_attribute_with_special_characters():
    # Test attribute name with special characters
    with pytest.raises(AttributeError) as excinfo:
        __getattr__('@nnash!') # 1.03μs -> 988ns (4.25% faster)

def test_edge_attribute_case_sensitivity():
    # Test that attribute lookup is case sensitive
    with pytest.raises(AttributeError) as excinfo:
        __getattr__('Nnash') # 981ns -> 892ns (9.98% faster)

def test_edge_attribute_with_whitespace():
    # Test attribute name with leading/trailing whitespace
    with pytest.raises(AttributeError) as excinfo:
        __getattr__(' nnash ') # 874ns -> 828ns (5.56% faster)






def test_edge_all_has_nonexistent_lqnash_attr():
    # Add a name to __all__ that _lqnash does not have
    global __all__
    old_all = __all__
    __all__ = ['nnash', 'missingattr']
    try:
        with pytest.raises(AttributeError):
            __getattr__('missingattr')
    finally:
        __all__ = old_all

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



def test_large_all_with_non_string_names():
    # Test that __all__ with non-string names still raises correct errors
    global __all__
    old_all = __all__
    __all__ = ['nnash', 123, None]
    try:
        # Valid string name works
        with warnings.catch_warnings(record=True):
            __getattr__('nnash')
        # Integer name works only if passed as string
        with pytest.raises(AttributeError):
            __getattr__('123')
        # Passing actual integer raises TypeError
        with pytest.raises(TypeError):
            __getattr__(123)
        # Passing None raises TypeError
        with pytest.raises(TypeError):
            __getattr__(None)
    finally:
        __all__ = old_all

def test_large_dir_returns_all():
    # Test that __dir__ returns __all__ for large __all__
    global __all__
    old_all = __all__
    names = [f"func_{i}" for i in range(1000)]
    __all__ = names
    __all__ = old_all
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import types
import warnings

# imports
import pytest  # used for our unit tests
from quantecon.lqnash import __getattr__

# function to test
# This file is not meant for public use and will be removed v0.8.0.
# Use the `quantecon` namespace for importing the objects
# included below.


# Simulate quantecon._lqnash for testing purposes
class DummyLQNash:
    # Simulate an attribute that should be accessible
    nnash = "dummy_nnash_value"

# Patch the _lqnash import for testing
_lqnash = DummyLQNash()

__all__ = ['nnash']

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

# unit tests

# --- Basic Test Cases ---

def test_getattr_basic_success():
    """
    Test that __getattr__ returns the correct attribute when called with a valid name.
    """
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        codeflash_output = __getattr__('nnash'); result = codeflash_output # 4.46μs -> 4.12μs (8.17% faster)

def test_getattr_basic_failure():
    """
    Test that __getattr__ raises AttributeError for an invalid attribute.
    """
    with pytest.raises(AttributeError) as excinfo:
        __getattr__('not_in_all') # 1.07μs -> 915ns (16.9% faster)

def test_getattr_dir_functionality():
    """
    Test that __dir__ returns the correct list of attributes.
    """

# --- Edge Test Cases ---

def test_getattr_empty_string():
    """
    Test that __getattr__ raises AttributeError when called with an empty string.
    """
    with pytest.raises(AttributeError) as excinfo:
        __getattr__('') # 1.03μs -> 847ns (21.1% faster)

def test_getattr_none_type():
    """
    Test that __getattr__ raises AttributeError when called with None.
    """
    with pytest.raises(AttributeError) as excinfo:
        __getattr__(None) # 1.24μs -> 1.16μs (6.19% faster)

def test_getattr_integer_type():
    """
    Test that __getattr__ raises AttributeError when called with an integer.
    """
    with pytest.raises(AttributeError) as excinfo:
        __getattr__(123) # 1.12μs -> 1.05μs (6.48% faster)


def test_getattr_case_sensitivity():
    """
    Test that __getattr__ is case sensitive (Python attributes are case sensitive).
    """
    with pytest.raises(AttributeError) as excinfo:
        __getattr__('NNash') # 1.18μs -> 1.08μs (9.37% faster)

def test_getattr_special_characters():
    """
    Test that __getattr__ raises AttributeError for attribute names with special characters.
    """
    with pytest.raises(AttributeError) as excinfo:
        __getattr__('nnash) # 1.01μs -> 932ns (8.58% faster)

# --- Large Scale Test Cases ---

To edit these changes git checkout codeflash/optimize-__getattr__-mggq7ikl and push.