⚡️ Speed up function _should_retry by 29%

[codeflash-ai]

📄 29% (0.29x) speedup for _should_retry in skyvern/client/core/http_client.py

⏱️ Runtime : 599 microseconds → 464 microseconds (best of 49 runs)

📝 Explanation and details

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import httpx  # used to construct Response objects
# imports
import pytest  # used for our unit tests
from skyvern.client.core.http_client import _should_retry

# unit tests

# ---------- BASIC TEST CASES ----------

def test_should_retry_returns_true_for_status_500():
    # Basic: Should retry for status code 500 (server error)
    response = httpx.Response(500)
    codeflash_output = _should_retry(response) # 548ns -> 407ns (34.6% faster)

def test_should_retry_returns_true_for_status_503():
    # Basic: Should retry for status code 503 (server error)
    response = httpx.Response(503)
    codeflash_output = _should_retry(response) # 477ns -> 366ns (30.3% faster)

def test_should_retry_returns_true_for_status_429():
    # Basic: Should retry for status code 429 (Too Many Requests)
    response = httpx.Response(429)
    codeflash_output = _should_retry(response) # 641ns -> 620ns (3.39% faster)

def test_should_retry_returns_true_for_status_408():
    # Basic: Should retry for status code 408 (Request Timeout)
    response = httpx.Response(408)
    codeflash_output = _should_retry(response) # 651ns -> 526ns (23.8% faster)

def test_should_retry_returns_true_for_status_409():
    # Basic: Should retry for status code 409 (Conflict)
    response = httpx.Response(409)
    codeflash_output = _should_retry(response) # 655ns -> 508ns (28.9% faster)

def test_should_retry_returns_false_for_status_200():
    # Basic: Should NOT retry for status code 200 (OK)
    response = httpx.Response(200)
    codeflash_output = _should_retry(response) # 630ns -> 463ns (36.1% faster)

def test_should_retry_returns_false_for_status_404():
    # Basic: Should NOT retry for status code 404 (Not Found)
    response = httpx.Response(404)
    codeflash_output = _should_retry(response) # 613ns -> 454ns (35.0% faster)

def test_should_retry_returns_false_for_status_400():
    # Basic: Should NOT retry for status code 400 (Bad Request)
    response = httpx.Response(400)
    codeflash_output = _should_retry(response) # 609ns -> 459ns (32.7% faster)

def test_should_retry_returns_false_for_status_401():
    # Basic: Should NOT retry for status code 401 (Unauthorized)
    response = httpx.Response(401)
    codeflash_output = _should_retry(response) # 630ns -> 450ns (40.0% faster)

def test_should_retry_returns_false_for_status_201():
    # Basic: Should NOT retry for status code 201 (Created)
    response = httpx.Response(201)
    codeflash_output = _should_retry(response) # 611ns -> 457ns (33.7% faster)

# ---------- EDGE TEST CASES ----------

def test_should_retry_returns_true_for_status_999():
    # Edge: Should retry for status code 999 (very high, unknown code, but >= 500)
    response = httpx.Response(999)
    codeflash_output = _should_retry(response) # 484ns -> 368ns (31.5% faster)

def test_should_retry_returns_false_for_status_499():
    # Edge: Should NOT retry for status code 499 (just below server error threshold)
    response = httpx.Response(499)
    codeflash_output = _should_retry(response) # 577ns -> 468ns (23.3% faster)

def test_should_retry_returns_true_for_status_500():
    # Edge: Should retry for status code 500 (exact threshold)
    response = httpx.Response(500)
    codeflash_output = _should_retry(response) # 548ns -> 407ns (34.6% faster)

def test_should_retry_returns_false_for_status_407():
    # Edge: Should NOT retry for status code 407 (Proxy Authentication Required, not in retryable_400s)
    response = httpx.Response(407)
    codeflash_output = _should_retry(response) # 577ns -> 432ns (33.6% faster)

def test_should_retry_returns_false_for_status_410():
    # Edge: Should NOT retry for status code 410 (Gone, not in retryable_400s)
    response = httpx.Response(410)
    codeflash_output = _should_retry(response) # 570ns -> 408ns (39.7% faster)

def test_should_retry_returns_false_for_status_0():
    # Edge: Should NOT retry for status code 0 (invalid/edge case)
    response = httpx.Response(0)
    codeflash_output = _should_retry(response) # 621ns -> 464ns (33.8% faster)

def test_should_retry_returns_false_for_negative_status_code():
    # Edge: Should NOT retry for negative status code (invalid/edge case)
    response = httpx.Response(-1)
    codeflash_output = _should_retry(response) # 617ns -> 436ns (41.5% faster)

def test_should_retry_returns_false_for_status_399():
    # Edge: Should NOT retry for status code 399 (not in retryable_400s, not >= 500)
    response = httpx.Response(399)
    codeflash_output = _should_retry(response) # 621ns -> 464ns (33.8% faster)

def test_should_retry_returns_false_for_status_100():
    # Edge: Should NOT retry for status code 100 (informational)
    response = httpx.Response(100)
    codeflash_output = _should_retry(response) # 607ns -> 431ns (40.8% faster)

def test_should_retry_returns_false_for_status_204():
    # Edge: Should NOT retry for status code 204 (No Content)
    response = httpx.Response(204)
    codeflash_output = _should_retry(response) # 581ns -> 442ns (31.4% faster)

# ---------- LARGE SCALE TEST CASES ----------

@pytest.mark.parametrize("status_code,expected", [
    # Parametrize a range of codes for scalability testing
    *[(code, True) for code in range(500, 600)],   # All 5xx should retry
    *[(code, False) for code in range(400, 408)],  # 400-407 should NOT retry (except 408, 409)
    (408, True),                                   # 408 should retry
    (409, True),                                   # 409 should retry
    *[(code, False) for code in range(410, 500)],  # 410-499 should NOT retry (except 429)
    (429, True),                                   # 429 should retry
    *[(code, False) for code in range(200, 400)],  # 2xx and 3xx should NOT retry
])
def test_should_retry_large_scale(status_code, expected):
    # Large scale: Test many status codes efficiently
    response = httpx.Response(status_code)
    codeflash_output = _should_retry(response) # 240μs -> 176μs (36.4% faster)

def test_should_retry_large_scale_random_sample():
    # Large scale: Test a random sample of codes in 0-999
    import random
    retryable_400s = [429, 408, 409]
    for _ in range(100):  # 100 random samples (well below 1000)
        code = random.randint(0, 999)
        response = httpx.Response(code)
        # Should retry if code >= 500 or in retryable_400s
        expected = (code >= 500) or (code in retryable_400s)
        codeflash_output = _should_retry(response) # 17.2μs -> 13.9μs (23.4% faster)

def test_should_retry_large_scale_batch():
    # Large scale: Test a batch of all codes from 0 to 999
    retryable_400s = [429, 408, 409]
    for code in range(1000):  # 0 to 999
        response = httpx.Response(code)
        expected = (code >= 500) or (code in retryable_400s)
        codeflash_output = _should_retry(response) # 146μs -> 119μs (23.5% faster)

# ---------- SPECIAL CASES ----------

def test_should_retry_with_custom_response_object():
    # Edge: Test with a custom object mimicking httpx.Response with status_code attribute
    class FakeResponse:
        def __init__(self, status_code):
            self.status_code = status_code
    # Should retry for 500
    codeflash_output = _should_retry(FakeResponse(500)) # 665ns -> 475ns (40.0% faster)
    # Should retry for 429
    codeflash_output = _should_retry(FakeResponse(429)) # 382ns -> 489ns (21.9% slower)
    # Should NOT retry for 404
    codeflash_output = _should_retry(FakeResponse(404)) # 198ns -> 150ns (32.0% faster)

def test_should_retry_with_non_integer_status_code():
    # Edge: Test with a non-integer status_code (should raise TypeError)
    class FakeResponse:
        def __init__(self, status_code):
            self.status_code = status_code
    # Should raise TypeError when comparing string to int
    with pytest.raises(TypeError):
        _should_retry(FakeResponse("500")) # 1.75μs -> 1.70μs (2.64% faster)

def test_should_retry_with_missing_status_code_attribute():
    # Edge: Test with object missing status_code attribute (should raise AttributeError)
    class FakeResponse:
        pass
    with pytest.raises(AttributeError):
        _should_retry(FakeResponse()) # 1.19μs -> 1.08μs (9.31% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import httpx
# imports
import pytest
from skyvern.client.core.http_client import _should_retry

# unit tests

# --- Basic Test Cases ---

def test_should_retry_status_code_500():
    # Should retry for status code 500 (server error)
    response = httpx.Response(500)
    codeflash_output = _should_retry(response) # 481ns -> 375ns (28.3% faster)

def test_should_retry_status_code_503():
    # Should retry for status code 503 (server error)
    response = httpx.Response(503)
    codeflash_output = _should_retry(response) # 486ns -> 368ns (32.1% faster)

def test_should_retry_status_code_429():
    # Should retry for status code 429 (Too Many Requests)
    response = httpx.Response(429)
    codeflash_output = _should_retry(response) # 609ns -> 580ns (5.00% faster)

def test_should_retry_status_code_408():
    # Should retry for status code 408 (Request Timeout)
    response = httpx.Response(408)
    codeflash_output = _should_retry(response) # 611ns -> 508ns (20.3% faster)

def test_should_retry_status_code_409():
    # Should retry for status code 409 (Conflict)
    response = httpx.Response(409)
    codeflash_output = _should_retry(response) # 631ns -> 497ns (27.0% faster)

def test_should_not_retry_status_code_404():
    # Should NOT retry for status code 404 (Not Found)
    response = httpx.Response(404)
    codeflash_output = _should_retry(response) # 603ns -> 476ns (26.7% faster)

def test_should_not_retry_status_code_200():
    # Should NOT retry for status code 200 (OK)
    response = httpx.Response(200)
    codeflash_output = _should_retry(response) # 645ns -> 456ns (41.4% faster)

def test_should_not_retry_status_code_400():
    # Should NOT retry for status code 400 (Bad Request)
    response = httpx.Response(400)
    codeflash_output = _should_retry(response) # 583ns -> 495ns (17.8% faster)

def test_should_not_retry_status_code_401():
    # Should NOT retry for status code 401 (Unauthorized)
    response = httpx.Response(401)
    codeflash_output = _should_retry(response) # 628ns -> 463ns (35.6% faster)

def test_should_not_retry_status_code_403():
    # Should NOT retry for status code 403 (Forbidden)
    response = httpx.Response(403)
    codeflash_output = _should_retry(response) # 583ns -> 469ns (24.3% faster)

# --- Edge Test Cases ---

def test_should_retry_status_code_599():
    # Should retry for status code 599 (highest possible 5xx)
    response = httpx.Response(599)
    codeflash_output = _should_retry(response) # 495ns -> 353ns (40.2% faster)

def test_should_not_retry_status_code_399():
    # Should NOT retry for status code 399 (highest possible 3xx)
    response = httpx.Response(399)
    codeflash_output = _should_retry(response) # 592ns -> 448ns (32.1% faster)

def test_should_not_retry_status_code_407():
    # Should NOT retry for status code 407 (Proxy Authentication Required)
    response = httpx.Response(407)
    codeflash_output = _should_retry(response) # 588ns -> 436ns (34.9% faster)

def test_should_not_retry_status_code_410():
    # Should NOT retry for status code 410 (Gone)
    response = httpx.Response(410)
    codeflash_output = _should_retry(response) # 624ns -> 415ns (50.4% faster)

def test_should_not_retry_status_code_418():
    # Should NOT retry for status code 418 (I'm a teapot)
    response = httpx.Response(418)
    codeflash_output = _should_retry(response) # 599ns -> 396ns (51.3% faster)

def test_should_not_retry_status_code_0():
    # Should NOT retry for status code 0 (invalid/edge case)
    response = httpx.Response(0)
    codeflash_output = _should_retry(response) # 636ns -> 479ns (32.8% faster)

def test_should_not_retry_status_code_negative():
    # Should NOT retry for negative status code (invalid/edge case)
    response = httpx.Response(-1)
    codeflash_output = _should_retry(response) # 606ns -> 435ns (39.3% faster)

def test_should_not_retry_status_code_1000():
    # Should NOT retry for status code 1000 (invalid/edge case)
    response = httpx.Response(1000)
    codeflash_output = _should_retry(response) # 492ns -> 346ns (42.2% faster)

def test_should_retry_status_code_500_boundary():
    # Should retry for status code 500 (boundary 5xx)
    response = httpx.Response(500)
    codeflash_output = _should_retry(response) # 496ns -> 350ns (41.7% faster)

def test_should_not_retry_status_code_499_boundary():
    # Should NOT retry for status code 499 (boundary before 5xx)
    response = httpx.Response(499)
    codeflash_output = _should_retry(response) # 617ns -> 460ns (34.1% faster)

# --- Large Scale Test Cases ---

def test_should_retry_all_5xx_status_codes():
    # Should retry for all status codes from 500 to 599
    for code in range(500, 600):
        response = httpx.Response(code)
        codeflash_output = _should_retry(response) # 14.1μs -> 10.7μs (31.4% faster)

def test_should_not_retry_all_4xx_except_retryable():
    # Should NOT retry for all 4xx except 408, 409, 429
    retryable_400s = {429, 408, 409}
    for code in range(400, 500):
        response = httpx.Response(code)
        expected = code in retryable_400s
        codeflash_output = _should_retry(response) # 17.1μs -> 14.0μs (22.8% faster)

def test_should_not_retry_all_3xx_status_codes():
    # Should NOT retry for all 3xx status codes
    for code in range(300, 400):
        response = httpx.Response(code)
        codeflash_output = _should_retry(response) # 16.8μs -> 13.8μs (21.9% faster)

def test_should_not_retry_all_2xx_status_codes():
    # Should NOT retry for all 2xx status codes
    for code in range(200, 300):
        response = httpx.Response(code)
        codeflash_output = _should_retry(response) # 17.1μs -> 13.9μs (23.3% faster)

def test_should_not_retry_all_1xx_status_codes():
    # Should NOT retry for all 1xx status codes
    for code in range(100, 200):
        response = httpx.Response(code)
        codeflash_output = _should_retry(response) # 17.0μs -> 13.7μs (24.0% faster)

def test_should_not_retry_random_large_status_codes():
    # Should NOT retry for random large status codes outside HTTP range
    large_codes = [600, 700, 800, 999]
    for code in large_codes:
        response = httpx.Response(code)
        codeflash_output = _should_retry(response) # 868ns -> 697ns (24.5% faster)

def test_should_retry_mixed_large_batch():
    # Test a batch of mixed status codes for performance and correctness
    retryable_400s = {429, 408, 409}
    codes = list(range(100, 600)) + [0, -1, 999]
    for code in codes:
        response = httpx.Response(code)
        if code >= 500 or code in retryable_400s:
            codeflash_output = _should_retry(response)
        else:
            codeflash_output = _should_retry(response)

# --- Additional Edge Case: Non-HTTP status codes ---

@pytest.mark.parametrize("code", [-100, 0, 99, 600, 1001])
def test_should_not_retry_non_http_status_codes(code):
    # Should NOT retry for non-standard HTTP status codes
    response = httpx.Response(code)
    codeflash_output = _should_retry(response) # 2.68μs -> 2.07μs (29.1% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-_should_retry-mi78b6eu and push.