Retries and Backoff

const RETRYABLE = new Set([429, 503, 504]);

async function withRetry<T>(
  fn: () => Promise<Response>,
  maxAttempts = 5,
  baseMs = 200,
  capMs = 20_000,
): Promise<Response> {
  let attempt = 0;
  for (;;) {
    let res: Response;
    try {
      res = await fn();
    } catch (err) {
      // Network error / timeout — retryable.
      if (++attempt >= maxAttempts) throw err;
      await sleep(backoff(attempt, baseMs, capMs));
      continue;
    }

    if (res.ok || (res.status >= 400 && res.status < 500 && !RETRYABLE.has(res.status))) {
      // Success, or a client error you must fix — don't retry.
      return res;
    }

    if (++attempt >= maxAttempts) return res;

    // Honor Retry-After (seconds) when the server sends it.
    const retryAfter = res.headers.get("Retry-After");
    const waitMs = retryAfter
      ? Math.max(Number(retryAfter) * 1000, backoff(attempt, baseMs, capMs))
      : backoff(attempt, baseMs, capMs);
    await sleep(waitMs);
  }
}

function backoff(attempt: number, baseMs: number, capMs: number): number {
  const exp = Math.min(capMs, baseMs * 2 ** (attempt - 1));
  return Math.random() * exp; // full jitter
}

const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

import random
import time

RETRYABLE = {429, 503, 504}

def with_retry(do_request, max_attempts=5, base_s=0.2, cap_s=20.0):
    attempt = 0
    while True:
        try:
            res = do_request()  # returns an object with .status_code and .headers
        except (ConnectionError, TimeoutError):
            attempt += 1
            if attempt >= max_attempts:
                raise
            time.sleep(_backoff(attempt, base_s, cap_s))
            continue

        if res.status_code < 500 and res.status_code not in RETRYABLE:
            # Success, or a client error you must fix — don't retry.
            return res

        attempt += 1
        if attempt >= max_attempts:
            return res

        retry_after = res.headers.get("Retry-After")
        wait_s = _backoff(attempt, base_s, cap_s)
        if retry_after:
            wait_s = max(float(retry_after), wait_s)
        time.sleep(wait_s)

def _backoff(attempt, base_s, cap_s):
    exp = min(cap_s, base_s * (2 ** (attempt - 1)))
    return random.random() * exp  # full jitter