⚡️ Speed up method UsageLimits.has_token_limits by 387%

[codeflash-ai]

📄 387% (3.87x) speedup for UsageLimits.has_token_limits in pydantic_ai_slim/pydantic_ai/usage.py

⏱️ Runtime : 352 microseconds → 72.2 microseconds (best of 174 runs)

📝 Explanation and details

REFINEMENT Here is a runtime and memory optimized version of your program, preserving the function signature and semantics.

Reasoning:

• Replaces the call to any() and tuple creation with a sequence of short-circuiting if checks.
• This avoids unnecessary creation of a tuple and the overhead of the generator, as well as potential additional overhead if the first attribute is not None (returns earlier).
• Reduces memory footprint and improves speed, especially when a limit is set early in the attribute list.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from dataclasses import dataclass

# imports
import pytest  # used for our unit tests
from pydantic_ai.usage import UsageLimits

# unit tests

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

def test_default_usage_limits_has_no_token_limits():
    # All token limits are None by default
    ul = UsageLimits()
    codeflash_output = ul.has_token_limits() # 459ns -> 125ns (267% faster)


















from dataclasses import dataclass

# imports
import pytest  # used for our unit tests
from pydantic_ai.usage import UsageLimits

# unit tests

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









def test_token_limits_large_integers():
    """Token limits set to very large integers, should return True."""
    limits = UsageLimits(
        request_limit=10,
        request_tokens_limit=2**60,
        response_tokens_limit=None,
        total_tokens_limit=None
    )
    codeflash_output = limits.has_token_limits() # 666ns -> 125ns (433% faster)

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

@pytest.mark.parametrize("request_tokens,response_tokens,total_tokens,expected", [
    # Only one set, rest None
    *[(i, None, None, True) for i in range(1, 1001, 250)],
    *[(None, i, None, True) for i in range(1, 1001, 250)],
    *[(None, None, i, True) for i in range(1, 1001, 250)],
    # All None
    (None, None, None, False),
    # All set
    (999, 888, 777, True),
    # Mixed
    (None, 888, None, True),
    (None, None, None, False),
])
def test_large_scale_varied_limits(request_tokens, response_tokens, total_tokens, expected):
    """Test large number of combinations for token limits."""
    limits = UsageLimits(
        request_limit=50,
        request_tokens_limit=request_tokens,
        response_tokens_limit=response_tokens,
        total_tokens_limit=total_tokens
    )
    codeflash_output = limits.has_token_limits() # 10.0μs -> 2.25μs (347% faster)

def test_large_scale_all_limits_none_many_instances():
    """Test that many UsageLimits instances with all None token limits return False."""
    for _ in range(500):  # Stay under 1000 as instructed
        limits = UsageLimits(
            request_limit=50,
            request_tokens_limit=None,
            response_tokens_limit=None,
            total_tokens_limit=None
        )
        codeflash_output = limits.has_token_limits() # 101μs -> 26.7μs (279% faster)

def test_large_scale_all_limits_set_many_instances():
    """Test that many UsageLimits instances with all token limits set return True."""
    for i in range(1, 501):  # Stay under 1000 as instructed
        limits = UsageLimits(
            request_limit=50,
            request_tokens_limit=i,
            response_tokens_limit=i + 1,
            total_tokens_limit=i + 2
        )
        codeflash_output = limits.has_token_limits() # 130μs -> 20.9μs (523% faster)

def test_large_scale_mixed_limits_many_instances():
    """Test many UsageLimits instances with mixed token limits."""
    for i in range(1, 501, 50):
        # Only one token limit set at a time
        limits1 = UsageLimits(request_limit=50, request_tokens_limit=i, response_tokens_limit=None, total_tokens_limit=None)
        limits2 = UsageLimits(request_limit=50, request_tokens_limit=None, response_tokens_limit=i, total_tokens_limit=None)
        limits3 = UsageLimits(request_limit=50, request_tokens_limit=None, response_tokens_limit=None, total_tokens_limit=i)
        codeflash_output = limits1.has_token_limits() # 3.41μs -> 500ns (583% faster)
        codeflash_output = limits2.has_token_limits()
        codeflash_output = limits3.has_token_limits() # 3.08μs -> 582ns (429% faster)
        # All None
        limits4 = UsageLimits(request_limit=50, request_tokens_limit=None, response_tokens_limit=None, total_tokens_limit=None)
        codeflash_output = limits4.has_token_limits() # 3.16μs -> 666ns (375% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from pydantic_ai.usage import UsageLimits

def test_UsageLimits_has_token_limits():
    UsageLimits.has_token_limits(UsageLimits(request_limit=None, request_tokens_limit=None, response_tokens_limit=0, total_tokens_limit=None))

To edit these changes git checkout codeflash/optimize-UsageLimits.has_token_limits-mddvvsfu and push.