⚡️ Speed up function lru_cache by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for lru_cache in src/anthropic/_utils/_utils.py

⏱️ Runtime : 36.7 microseconds → 33.6 microseconds (best of 372 runs)

📝 Explanation and details

The optimization introduces caching for the default decorator instance to avoid repeated expensive calls to functools.lru_cache().

Key change: When maxsize=128 (the default), the optimized version stores and reuses a single functools.lru_cache instance via function attributes (hasattr/setattr/getattr), rather than creating a new one on every call.

Why this speeds up performance:

• functools.lru_cache() has non-trivial overhead for instance creation
• The default maxsize=128 is used frequently in practice (as evidenced by the test cases)
• By caching the decorator instance, subsequent calls with default arguments skip the expensive functools.lru_cache() construction

Performance characteristics:

• 9% speedup overall, with the optimization being most effective when the lru_cache function is called repeatedly with the default maxsize=128
• The line profiler shows the original version spent 73% of time in functools.lru_cache() creation, while the optimized version distributes this cost and reduces it for repeat calls
• Non-default maxsize values still use the original code path, so no regression for edge cases

Test case effectiveness: This optimization particularly benefits scenarios with multiple function decorations using default cache settings, which is common in production codebases where @lru_cache() is applied frequently across different functions.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import functools
import time
from typing import Any, Callable, TypeVar, cast

# imports
import pytest  # used for our unit tests
from anthropic._utils._utils import lru_cache

CallableT = TypeVar("CallableT", bound=Callable[..., Any])
from anthropic._utils._utils import lru_cache

# unit tests

# Basic Test Cases

def test_basic_cache_hits_and_misses():
    # Test that repeated calls with the same arguments hit the cache
    call_counter = {'count': 0}
    @lru_cache()
    def add(a, b):
        call_counter['count'] += 1
        return a + b

def test_basic_cache_with_kwargs():
    # Test that kwargs are handled correctly
    call_counter = {'count': 0}
    @lru_cache()
    def concat(a, b='foo'):
        call_counter['count'] += 1
        return f"{a}-{b}"

def test_cache_maxsize_eviction():
    # Test that cache evicts least recently used items when maxsize is exceeded
    call_counter = {'count': 0}
    @lru_cache(maxsize=2)
    def square(x):
        call_counter['count'] += 1
        return x * x

def test_cache_with_none_maxsize():
    # Test that cache works with unlimited size (maxsize=None)
    call_counter = {'count': 0}
    @lru_cache(maxsize=None)
    def identity(x):
        call_counter['count'] += 1
        return x

    for i in range(10):
        pass
    # Repeating calls should hit cache
    for i in range(10):
        pass

def test_cache_preserves_type_signature():
    # Test that the decorator does not change the function's type signature
    @lru_cache()
    def foo(x: int) -> int:
        return x + 1

# Edge Test Cases


def test_cache_with_mutable_default_args():
    # lru_cache should treat mutable default args as separate cache keys
    call_counter = {'count': 0}
    @lru_cache()
    def f(x, y=None):
        call_counter['count'] += 1
        if y is None:
            y = []
        return x + len(y)

def test_cache_with_different_types():
    # lru_cache should distinguish keys by argument type
    call_counter = {'count': 0}
    @lru_cache()
    def stringify(x):
        call_counter['count'] += 1
        return str(x)

def test_cache_with_large_maxsize_and_eviction():
    # Test eviction logic with a large but finite cache
    call_counter = {'count': 0}
    @lru_cache(maxsize=10)
    def double(x):
        call_counter['count'] += 1
        return x * 2

    # Fill cache
    for i in range(10):
        pass
    # Add new entries to force eviction
    for i in range(10, 13):
        pass

def test_cache_with_no_args():
    # lru_cache should work with functions that take no arguments
    call_counter = {'count': 0}
    @lru_cache()
    def get_time():
        call_counter['count'] += 1
        return 42

def test_cache_with_kwargs_only():
    # lru_cache should work with kwargs-only functions
    call_counter = {'count': 0}
    @lru_cache()
    def foo(*, x, y=3):
        call_counter['count'] += 1
        return x + y

# Large Scale Test Cases

def test_cache_performance_large_scale():
    # Test that lru_cache can handle many unique keys efficiently
    call_counter = {'count': 0}
    @lru_cache(maxsize=1000)
    def triple(x):
        call_counter['count'] += 1
        return x * 3

    for i in range(1000):
        pass
    # All keys are in cache, so repeated calls should hit cache
    for i in range(1000):
        pass

def test_cache_eviction_large_scale():
    # Test that cache evicts old keys when maxsize is reached
    call_counter = {'count': 0}
    @lru_cache(maxsize=100)
    def quadruple(x):
        call_counter['count'] += 1
        return x * 4

    # Fill cache
    for i in range(100):
        pass
    # Add new entries to force eviction
    for i in range(100, 200):
        pass
    # Access evicted keys
    for i in range(100):
        pass

def test_cache_with_large_complex_args():
    # Test lru_cache with large tuples as arguments
    call_counter = {'count': 0}
    @lru_cache(maxsize=100)
    def sum_tuple(t):
        call_counter['count'] += 1
        return sum(t)

    tuples = [tuple(range(i, i+10)) for i in range(100)]
    for t in tuples:
        pass
    # All tuples are unique, so repeated calls should hit cache
    for t in tuples:
        pass

def test_cache_thread_safety():
    # Test that lru_cache is thread-safe for basic usage
    import threading
    call_counter = {'count': 0}
    @lru_cache(maxsize=100)
    def multiply(x):
        call_counter['count'] += 1
        return x * 5

    def worker():
        for i in range(100):
            pass

    threads = [threading.Thread(target=worker) for _ in range(5)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()

def test_cache_with_large_kwargs():
    # Test lru_cache with many unique kwargs
    call_counter = {'count': 0}
    @lru_cache(maxsize=1000)
    def f(**kwargs):
        call_counter['count'] += 1
        return sum(kwargs.values())

    for i in range(1000):
        pass
    # Repeating calls should hit cache
    for i in range(1000):
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

import functools
import time
from typing import Any, Callable, TypeVar, cast

# imports
import pytest  # used for our unit tests
from anthropic._utils._utils import lru_cache

CallableT = TypeVar("CallableT", bound=Callable[..., Any])
from anthropic._utils._utils import lru_cache

# unit tests

# 1. Basic Test Cases

def test_lru_cache_basic_caching():
    # Test that repeated calls with the same arguments return cached results
    call_counter = {"count": 0}

    @lru_cache()
    def add(a, b):
        call_counter["count"] += 1
        return a + b

def test_lru_cache_basic_type_signature():
    # Test that the decorator preserves the type signature
    @lru_cache()
    def concat(a: str, b: str) -> str:
        return a + b

def test_lru_cache_basic_with_kwargs():
    # Test that kwargs are handled correctly
    call_counter = {"count": 0}

    @lru_cache()
    def func(a, b=1):
        call_counter["count"] += 1
        return a + b

def test_lru_cache_basic_multiple_functions():
    # Test that multiple functions have independent caches
    call_counter1 = {"count": 0}
    call_counter2 = {"count": 0}

    @lru_cache()
    def f1(x):
        call_counter1["count"] += 1
        return x * 2

    @lru_cache()
    def f2(x):
        call_counter2["count"] += 1
        return x * 3

# 2. Edge Test Cases

def test_lru_cache_edge_maxsize_zero():
    # maxsize=0 disables caching (calls every time)
    call_counter = {"count": 0}

    @lru_cache(maxsize=0)
    def func(x):
        call_counter["count"] += 1
        return x + 1

def test_lru_cache_edge_maxsize_none():
    # maxsize=None means unlimited cache
    call_counter = {"count": 0}

    @lru_cache(maxsize=None)
    def func(x):
        call_counter["count"] += 1
        return x * 2

    for i in range(10):
        pass

    # Repeating should not increment
    for i in range(10):
        pass


def test_lru_cache_edge_different_types():
    # Different types should be cached separately
    call_counter = {"count": 0}

    @lru_cache()
    def func(x):
        call_counter["count"] += 1
        return str(x)

def test_lru_cache_edge_mutable_default_argument():
    # Mutable default arguments should not break cache
    call_counter = {"count": 0}

    @lru_cache()
    def func(x, y=[]):
        call_counter["count"] += 1
        return x + len(y)

def test_lru_cache_edge_keyword_only_arguments():
    # Keyword-only arguments should be part of cache key
    call_counter = {"count": 0}

    @lru_cache()
    def func(x, *, y=0):
        call_counter["count"] += 1
        return x + y



def test_lru_cache_large_maxsize_eviction():
    # Test eviction policy with large maxsize
    call_counter = {"count": 0}

    @lru_cache(maxsize=100)
    def func(x):
        call_counter["count"] += 1
        return x * x

    # Fill cache
    for i in range(100):
        pass

    # All entries should be cached
    for i in range(100):
        pass

    # Add new entries to cause eviction
    for i in range(100, 110):
        pass

    # The first 10 should have been evicted (LRU)
    for i in range(10):
        pass

def test_lru_cache_large_maxsize_none():
    # Test unlimited cache with many entries
    call_counter = {"count": 0}

    @lru_cache(maxsize=None)
    def func(x):
        call_counter["count"] += 1
        return x + 1

    for i in range(500):
        pass
    for i in range(500):
        pass

def test_lru_cache_large_performance():
    # Test that cache speeds up repeated calls
    call_counter = {"count": 0}

    @lru_cache(maxsize=256)
    def slow_func(x):
        call_counter["count"] += 1
        # Simulate slow computation
        time.sleep(0.001)
        return x * 2

    # First pass: slow
    start = time.time()
    for i in range(256):
        pass
    duration_first = time.time() - start

    # Second pass: should be much faster
    start = time.time()
    for i in range(256):
        pass
    duration_second = time.time() - start

def test_lru_cache_large_with_kwargs():
    # Test caching with many distinct kwargs
    call_counter = {"count": 0}

    @lru_cache(maxsize=500)
    def func(a, b=0):
        call_counter["count"] += 1
        return a + b

    for i in range(250):
        pass
    for i in range(250):
        pass

def test_lru_cache_large_multiple_functions():
    # Large scale: multiple cached functions with independent caches
    call_counter1 = {"count": 0}
    call_counter2 = {"count": 0}

    @lru_cache(maxsize=300)
    def f1(x):
        call_counter1["count"] += 1
        return x * 2

    @lru_cache(maxsize=300)
    def f2(x):
        call_counter2["count"] += 1
        return x * 3

    for i in range(300):
        pass

    for i in range(300):
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from anthropic._utils._utils import lru_cache
from functools import lru_cache

def test_lru_cache():
    lru_cache(maxsize=0)

To edit these changes git checkout codeflash/optimize-lru_cache-mhe1qnmd and push.