Erros e limites

const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
const MAX_RETRIES = 5;
const BASE_DELAY_MS = 1_000;
const MAX_DELAY_MS = 60_000;

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

/** Backoff exponencial com "full jitter": aleatório em [0, teto]. */
function backoffMs(attempt) {
  const ceiling = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** attempt);
  return Math.random() * ceiling;
}

export async function trynoFetch(path, { apiKey, ...init } = {}) {
  let lastError;

  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
    let res;
    try {
      res = await fetch(`https://tryno.io/api/v1${path}`, {
        ...init,
        headers: { ...init.headers, Authorization: `Bearer ${apiKey}` },
      });
    } catch (err) {
      // Falha de rede — também é retentável.
      lastError = err;
      if (attempt === MAX_RETRIES) throw err;
      await sleep(backoffMs(attempt));
      continue;
    }

    if (res.ok) return res.json();

    const body = await res.json().catch(() => ({}));
    const type = body?.error?.type;

    // Erros de configuração: repetir não conserta. Falhe alto.
    if (!RETRYABLE_STATUS.has(res.status)) {
      throw new Error(`Tryno ${res.status} ${type ?? "unknown"}: ${body?.error?.message ?? ""}`);
    }

    if (attempt === MAX_RETRIES) {
      throw new Error(`Tryno ${res.status} ${type ?? "unknown"} após ${MAX_RETRIES} retentativas`);
    }

    // Retry-After vem em SEGUNDOS e só aparece no 429 (sempre "60").
    const retryAfter = Number(res.headers.get("retry-after"));
    const wait = Number.isFinite(retryAfter) && retryAfter > 0
      // Respeite o servidor, mas some jitter: senão todos os seus workers
      // voltam exatamente no mesmo milissegundo e estouram o teto de novo.
      ? retryAfter * 1000 + Math.random() * 1_000
      : backoffMs(attempt);

    await sleep(wait);
  }

  throw lastError ?? new Error("Tryno: retentativas esgotadas");
}

import os
import random
import time

import requests

RETRYABLE_STATUS = {429, 500, 502, 503, 504}
MAX_RETRIES = 5
BASE_DELAY_S = 1.0
MAX_DELAY_S = 60.0

BASE_URL = "https://tryno.io/api/v1"


def _backoff_s(attempt: int) -> float:
    """Backoff exponencial com full jitter: aleatório em [0, teto]."""
    ceiling = min(MAX_DELAY_S, BASE_DELAY_S * (2**attempt))
    return random.uniform(0, ceiling)


class TrynoError(RuntimeError):
    def __init__(self, status: int, type_: str | None, message: str = ""):
        super().__init__(f"Tryno {status} {type_ or 'unknown'}: {message}")
        self.status = status
        self.type = type_


def tryno_get(path: str, params: dict | None = None, api_key: str | None = None):
    key = api_key or os.environ["TRYNO_API_KEY"]
    session = requests.Session()

    for attempt in range(MAX_RETRIES + 1):
        try:
            res = session.get(
                f"{BASE_URL}{path}",
                params=params,
                headers={"Authorization": f"Bearer {key}"},
                timeout=10,
            )
        except requests.RequestException:
            if attempt == MAX_RETRIES:
                raise
            time.sleep(_backoff_s(attempt))
            continue

        if res.ok:
            return res.json()

        try:
            err = res.json().get("error", {})
        except ValueError:
            err = {}

        # 401 / 403 / 404: configuração errada. Falhe alto, não repita.
        if res.status_code not in RETRYABLE_STATUS or attempt == MAX_RETRIES:
            raise TrynoError(res.status_code, err.get("type"), err.get("message", ""))

        # Retry-After chega em SEGUNDOS e só no 429. Some jitter mesmo assim.
        retry_after = res.headers.get("Retry-After")
        if retry_after and retry_after.isdigit():
            wait = int(retry_after) + random.uniform(0, 1)
        else:
            wait = _backoff_s(attempt)

        time.sleep(wait)

    raise TrynoError(0, "exhausted")