⚡️ Speed up function time_based_cache by 11%

[codeflash-ai]

📄 11% (0.11x) speedup for time_based_cache in src/dsa/caching_memoization.py

⏱️ Runtime : 78.4 microseconds → 70.3 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves an 11% speedup by eliminating expensive string operations in cache key generation and streamlining cache lookups.

Key optimizations:

1. Tuple-based cache keys instead of string concatenation: The original code builds cache keys by calling repr() on each argument and joining them with colons (":".join(key_parts)). The optimized version uses tuples directly as keys - (args, tuple(sorted(kwargs.items()))) when kwargs exist, or just args when no kwargs. This eliminates multiple string allocations and concatenations.

2. Single cache lookup with dict.get(): Instead of checking key in cache followed by cache[key], the optimized code uses cache.get(key) which performs only one hash lookup and returns None if the key doesn't exist.

3. Conditional key construction: Only processes kwargs when they exist, avoiding unnecessary tuple creation for the common case of functions with only positional arguments.

Why this is faster:

• Tuples are hashable and don't require string conversion/concatenation overhead
• Single dictionary lookup vs. two lookups reduces hash computation
• Fewer object allocations (no intermediate strings or lists)

Best suited for: Functions with simple argument types that are called frequently, especially those with only positional arguments or consistent kwargs patterns. The optimization is most effective when cache hit rates are high, as the key generation savings compound with each cache access.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 25 Passed
🌀 Generated Regression Tests	✅ 23 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 1 Passed
🔮 Hypothesis Tests	✅ 100 Passed
📊 Tests Coverage	100.0%

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_hypothesis_399nzc3e/test_hypothesis.py::test_fuzz_time_based_cache	55.5μs	49.3μs	12.6%✅
test_dsa_nodes.py::test_cache_hit	2.21μs	1.42μs	55.8%✅
test_dsa_nodes.py::test_different_arguments	875ns	709ns	23.4%✅
test_dsa_nodes.py::test_different_cache_instances	1.87μs	1.38μs	36.3%✅
test_dsa_nodes.py::test_keyword_arguments	667ns	625ns	6.72%✅

🌀 Generated Regression Tests and Runtime

import time
from typing import Any, Callable

# imports
import pytest
from src.dsa.caching_memoization import time_based_cache

# unit tests

# --- Basic Test Cases ---

def test_cache_basic_same_args():
    """Test that repeated calls with the same arguments within expiry use the cache."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x):
        calls.append(x)
        return x + 1

def test_cache_basic_different_args():
    """Test that different arguments are cached separately."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x):
        calls.append(x)
        return x * 2

def test_cache_basic_with_kwargs():
    """Test that kwargs are included in cache key."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x, y=0):
        calls.append((x, y))
        return x + y

def test_cache_basic_positional_and_keyword():
    """Test mixed positional and keyword arguments."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(a, b, c=5):
        calls.append((a, b, c))
        return a + b + c


# --- Edge Test Cases ---

def test_cache_expiry():
    """Test that cache expires after the expiry_seconds."""
    calls = []
    @time_based_cache(expiry_seconds=1)
    def f(x):
        calls.append(x)
        return x * 3
    time.sleep(1.1)  # Wait for cache to expire

def test_cache_zero_expiry():
    """Test that expiry_seconds=0 disables caching (always calls function)."""
    calls = []
    @time_based_cache(expiry_seconds=0)
    def f(x):
        calls.append(x)
        return x - 1

def test_cache_negative_expiry():
    """Test that negative expiry disables caching (always calls function)."""
    calls = []
    @time_based_cache(expiry_seconds=-3)
    def f(x):
        calls.append(x)
        return x * x

def test_cache_mutable_args():
    """Test that mutable arguments (lists, dicts) are handled via repr in key."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x):
        calls.append(x)
        return sum(x)

    a = [1,2]
    b = [1,2]

    a2 = [2,1]

def test_cache_kwargs_order_irrelevant():
    """Test that kwargs order does not affect cache key."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x=1, y=2):
        calls.append((x, y))
        return x * y

def test_cache_large_args():
    """Test that large arguments (long strings) are handled."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x):
        calls.append(x)
        return len(x)

    s = "a" * 500

def test_cache_unhashable_kwargs():
    """Test that unhashable kwargs (lists as values) are handled via repr."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x=1, y=None):
        calls.append((x, y))
        return x + (sum(y) if y else 0)

def test_cache_different_types_same_repr():
    """Test that different types with same repr are cached separately."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x):
        calls.append(type(x))
        return str(x)

def test_cache_none_args():
    """Test that None as argument is handled."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x):
        calls.append(x)
        return x is None

def test_cache_empty_args():
    """Test that function with no arguments is cached."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f():
        calls.append(1)
        return 42


# --- Large Scale Test Cases ---

def test_cache_many_unique_args():
    """Test caching with many unique arguments."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x):
        calls.append(x)
        return x * 2

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

def test_cache_many_calls_same_arg():
    """Test repeated calls with same arg, only first is computed."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x):
        calls.append(x)
        return x + 10

    for _ in range(200):
        pass

def test_cache_expiry_many_args():
    """Test expiry for many unique arguments."""
    calls = []
    @time_based_cache(expiry_seconds=1)
    def f(x):
        calls.append(x)
        return x + 1

    for i in range(50):
        pass
    time.sleep(1.05)
    for i in range(50):
        pass

def test_cache_large_kwargs():
    """Test caching with many keyword arguments."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(**kwargs):
        calls.append(kwargs)
        return sum(kwargs.values())

    d = {f"k{i}": i for i in range(50)}

def test_cache_large_mutable_args():
    """Test caching with large mutable arguments."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x):
        calls.append(x)
        return sum(x)

    big_list = list(range(500))

def test_cache_scalability():
    """Test scalability with a mix of args and kwargs."""
    calls = []
    @time_based_cache(expiry_seconds=10)
    def f(x, y=0, z=0):
        calls.append((x, y, z))
        return x + y + z

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

# Additional: Ensure decorator does not interfere with function attributes
def test_cache_preserves_function_name_and_doc():
    """Test that the decorator preserves function metadata."""
    @time_based_cache(expiry_seconds=10)
    def f(x):
        """Docstring!"""
        return x

# Additional: Ensure cache is per-decorated-function, not shared
def test_cache_is_per_function():
    """Test that caches are not shared between decorated functions."""
    calls1 = []
    calls2 = []
    @time_based_cache(expiry_seconds=10)
    def f(x):
        calls1.append(x)
        return x + 1
    @time_based_cache(expiry_seconds=10)
    def g(x):
        calls2.append(x)
        return x + 2
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from src.dsa.caching_memoization import time_based_cache

def test_time_based_cache():
    time_based_cache(0)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_fb1xiyqb/tmp2ko0xvtp/test_concolic_coverage.py::test_time_based_cache	625ns	583ns	7.20%✅

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