⚡️ Speed up function time_based_cache by 10%

[codeflash-ai]

📄 10% (0.10x) speedup for time_based_cache in src/algorithms/caching.py

⏱️ Runtime : 63.9 microseconds → 58.1 microseconds (best of 5 runs)

📝 Explanation and details

The optimized version replaces string-based cache key generation with tuple-based keys, delivering a 9% performance improvement. The key optimization is in how cache keys are constructed:

Original approach: Creates cache keys by converting each argument to its string representation using repr(), then joining them with colons. This involves multiple string operations:

• repr(arg) for each positional argument
• f"{k}:{repr(v)}" formatting for each keyword argument
• ":".join(key_parts) to concatenate everything

Optimized approach: Uses a make_key() function that creates tuple-based keys directly:

• Positional arguments are already a tuple (args)
• Keyword arguments become tuple(sorted(kwargs.items())) when present
• Returns (args, items) or (args, None) as the cache key

Why this is faster:

1. Eliminates string operations: No repr() calls, string formatting, or joining operations needed
2. Native tuple hashing: Python's built-in tuple hashing is highly optimized and faster than string hashing
3. Reduced memory allocation: Tuples reuse existing argument structures rather than creating new strings
4. Better cache lookup performance: Dictionary lookups with tuple keys are more efficient

The test results show this optimization is particularly effective for:

• Functions with many arguments (large args/kwargs test cases)
• Repeated cache hits (500+ repeated calls scenarios)
• Mixed argument types where repr() overhead would be significant

Since cache key generation happens on every function call (both hits and misses), this optimization provides consistent performance benefits regardless of cache hit rate. The 9% speedup compounds especially well for frequently called decorated functions.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 25 Passed
🌀 Generated Regression Tests	✅ 35 Passed
⏪ Replay Tests	✅ 7 Passed
🔎 Concolic Coverage Tests	✅ 1 Passed
📊 Tests Coverage	100.0%

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_dsa_nodes.py::test_cache_hit	1.21μs	1.42μs	-14.7%⚠️
test_dsa_nodes.py::test_different_arguments	1.58μs	1.12μs	40.7%✅
test_dsa_nodes.py::test_different_cache_instances	1.96μs	1.54μs	27.1%✅
test_dsa_nodes.py::test_keyword_arguments	875ns	833ns	5.04%✅

🌀 Generated Regression Tests and Runtime

import time

# imports
import pytest  # used for our unit tests
from src.algorithms.caching import time_based_cache

# unit tests

# ---- Basic Test Cases ----
def test_basic_cache_hit_and_miss():
    # Test that the cache stores and returns a value within expiry
    calls = []
    @time_based_cache(expiry_seconds=2)
    def add(x, y):
        calls.append((x, y))
        return x + y

def test_basic_cache_different_args():
    # Test that different arguments are cached separately
    calls = []
    @time_based_cache(expiry_seconds=2)
    def mul(x, y):
        calls.append((x, y))
        return x * y

def test_basic_cache_with_kwargs():
    # Test that kwargs are included in the cache key
    calls = []
    @time_based_cache(expiry_seconds=2)
    def greet(name, greeting="Hello"):
        calls.append((name, greeting))
        return f"{greeting}, {name}"

def test_basic_cache_expiry():
    # Test that cache expires after expiry_seconds
    calls = []
    @time_based_cache(expiry_seconds=1)
    def inc(x):
        calls.append(x)
        return x + 1

    # Wait for expiry
    time.sleep(1.1)

# ---- Edge Test Cases ----
def test_cache_zero_expiry():
    # Test expiry_seconds=0 means no caching
    calls = []
    @time_based_cache(expiry_seconds=0)
    def f(x):
        calls.append(x)
        return x * 2

def test_cache_negative_expiry():
    # Test negative expiry means no caching
    calls = []
    @time_based_cache(expiry_seconds=-10)
    def f(x):
        calls.append(x)
        return x * 3

def test_cache_with_unhashable_args():
    # Test that unhashable args (like lists) are handled by repr in key
    calls = []
    @time_based_cache(expiry_seconds=2)
    def concat(lst):
        calls.append(list(lst))
        return "".join(lst)

def test_cache_with_mutable_args_changes():
    # Changing the contents of a mutable argument should result in a different cache key
    calls = []
    @time_based_cache(expiry_seconds=2)
    def sum_list(lst):
        calls.append(list(lst))
        return sum(lst)

    l = [1, 2]
    l.append(3)

def test_cache_with_kwargs_order():
    # Test that kwargs order does not affect cache key
    calls = []
    @time_based_cache(expiry_seconds=2)
    def foo(a, b=0, c=0):
        calls.append((a, b, c))
        return a + b + c

def test_cache_with_many_args_and_kwargs():
    # Test that many args and kwargs are handled
    calls = []
    @time_based_cache(expiry_seconds=2)
    def bar(*args, **kwargs):
        calls.append((args, kwargs))
        return sum(args) + sum(kwargs.values())

def test_cache_with_none_args():
    # Test that None is handled in arguments
    calls = []
    @time_based_cache(expiry_seconds=2)
    def f(x, y=None):
        calls.append((x, y))
        return (x, y)

def test_cache_with_empty_args():
    # Test that function with no args is cached
    calls = []
    @time_based_cache(expiry_seconds=2)
    def f():
        calls.append(1)
        return 42

# ---- Large Scale Test Cases ----
def test_cache_large_number_of_unique_keys():
    # Test caching with many unique keys
    calls = []
    @time_based_cache(expiry_seconds=2)
    def f(x):
        calls.append(x)
        return x * x

    # Call with 500 unique values
    for i in range(500):
        pass

    # Repeat, should all be cached
    for i in range(500):
        pass

def test_cache_large_number_of_repeated_keys():
    # Test repeated calls to the same key
    calls = []
    @time_based_cache(expiry_seconds=2)
    def f(x):
        calls.append(x)
        return x + 1

    for _ in range(500):
        pass

def test_cache_large_args_and_kwargs():
    # Test with large number of args and kwargs
    calls = []
    @time_based_cache(expiry_seconds=2)
    def f(*args, **kwargs):
        calls.append((args, kwargs))
        return sum(args) + sum(kwargs.values())

    args = tuple(range(100))
    kwargs = {f'k{i}': i for i in range(100)}
    expected = sum(args) + sum(kwargs.values())

def test_cache_expiry_with_large_data():
    # Test cache expiry with many keys
    calls = []
    @time_based_cache(expiry_seconds=1)
    def f(x):
        calls.append(x)
        return x * 2

    for i in range(300):
        pass

    # Wait for expiry
    time.sleep(1.1)
    for i in range(300):
        pass

def test_cache_performance_under_load():
    # Test performance: repeated calls to cached values should be fast
    calls = []
    @time_based_cache(expiry_seconds=2)
    def f(x):
        calls.append(x)
        return x + 1

    start = time.time()
    for i in range(100):
        for _ in range(10):
            pass
    elapsed = time.time() - start
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import time

# imports
import pytest
from src.algorithms.caching import time_based_cache

# unit tests

# BASIC TEST CASES

def test_basic_cache_hits():
    """Test that repeated calls within expiry return cached result."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def foo(x):
        calls.append(x)
        return x * 2

def test_basic_cache_miss_after_expiry():
    """Test that cache expires after expiry_seconds."""
    calls = []
    @time_based_cache(expiry_seconds=1)
    def bar(x):
        calls.append(x)
        return x + 1
    time.sleep(1.1)  # Wait for cache expiry

def test_cache_with_different_args():
    """Test that different arguments produce different cache entries."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def baz(x):
        calls.append(x)
        return x * 3

def test_cache_with_kwargs():
    """Test that kwargs are part of the cache key."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def qux(x, y=5):
        calls.append((x, y))
        return x + y

def test_cache_with_mixed_args_kwargs():
    """Test cache key with both args and kwargs."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def foo(x, y=0, z=0):
        calls.append((x, y, z))
        return x + y + z

# EDGE TEST CASES

def test_zero_expiry_always_miss():
    """Test that expiry_seconds=0 always misses cache."""
    calls = []
    @time_based_cache(expiry_seconds=0)
    def foo(x):
        calls.append(x)
        return x * 2

def test_negative_expiry_always_miss():
    """Test that negative expiry always misses cache."""
    calls = []
    @time_based_cache(expiry_seconds=-5)
    def foo(x):
        calls.append(x)
        return x * 2

def test_cache_with_unhashable_args():
    """Test that unhashable args (e.g. list) are handled via repr."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def foo(x):
        calls.append(x)
        return sum(x)

def test_cache_with_multiple_args_types():
    """Test cache key works with mixed types."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def foo(a, b, c=None):
        calls.append((a, b, c))
        return str(a) + str(b) + str(c)

def test_cache_key_collisions():
    """Test that different argument combinations do not collide."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def foo(x, y):
        calls.append((x, y))
        return x + y

def test_cache_expiry_precision():
    """Test that cache expires at the correct time boundary."""
    calls = []
    @time_based_cache(expiry_seconds=0.5)
    def foo(x):
        calls.append(x)
        return x * 2
    time.sleep(0.4)
    time.sleep(0.2)

def test_cache_with_no_args():
    """Test caching works for functions with no arguments."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def foo():
        calls.append("called")
        return 42

def test_cache_with_large_object_args():
    """Test that large objects as args are handled correctly."""
    calls = []
    big_list = list(range(500))
    @time_based_cache(expiry_seconds=2)
    def foo(x):
        calls.append(x)
        return sum(x)

# LARGE SCALE TEST CASES

def test_cache_large_number_of_unique_keys():
    """Test cache performance and correctness with many unique keys."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def foo(x):
        calls.append(x)
        return x * x

    # Test with 500 unique keys
    for i in range(500):
        pass

    # Call again, should all be cached
    for i in range(500):
        pass

def test_cache_large_number_of_repeated_calls():
    """Test cache hit rate with many repeated calls."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def foo(x):
        calls.append(x)
        return x + 10

    # Call same key 500 times
    for _ in range(500):
        pass

def test_cache_expiry_with_many_keys():
    """Test cache expiry for many keys."""
    calls = []
    @time_based_cache(expiry_seconds=1)
    def foo(x):
        calls.append(x)
        return x + 1

    for i in range(100):
        pass

    time.sleep(1.1)  # Wait for expiry

    for i in range(100):
        pass

def test_cache_with_large_kwargs():
    """Test cache key construction with large number of kwargs."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def foo(**kwargs):
        calls.append(kwargs)
        return sum(kwargs.values())

    big_kwargs = {f"k{i}": i for i in range(100)}

def test_cache_with_large_args_and_kwargs():
    """Test cache with both large args and kwargs."""
    calls = []
    @time_based_cache(expiry_seconds=2)
    def foo(*args, **kwargs):
        calls.append((args, kwargs))
        return sum(args) + sum(kwargs.values())

    big_args = tuple(range(50))
    big_kwargs = {f"k{i}": i for i in range(50)}
    expected = sum(big_args) + sum(big_kwargs.values())
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from src.algorithms.caching import time_based_cache

def test_time_based_cache():
    time_based_cache(0)

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pytest_tests__replay_test_0.py::test_src_algorithms_caching_time_based_cache	7.17μs	6.54μs	9.57%✅

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_wqbg8ft3/tmp9l861_eq/test_concolic_coverage.py::test_time_based_cache	625ns	625ns	0.000%✅

To edit these changes git checkout codeflash/optimize-time_based_cache-mho4j682 and push.