Como implementar retry automático em consultas de CPF que falham

import requests
import time
import random

def consultar_cpf_com_retry(cpf, max_tentativas=3):
    url = f"https://api.cpfhub.io/cpf/{cpf}"
    headers = {
    "x-api-key": "SUA_CHAVE_DE_API",
    "Accept": "application/json"
    }

    codigos_retry = {500, 503}

    for tentativa in range(max_tentativas):
    try:
    response = requests.get(url, headers=headers, timeout=10)

    # Sucesso: retornar dados
    if response.status_code == 200:
    return response.json()

    # Erro permanente: não fazer retry
    if response.status_code in (400, 401, 404):
    return {
    "erro": f"Erro {response.status_code}",
    "retry": False
    }

    # Erro temporário: fazer retry
    if response.status_code in codigos_retry:
    if tentativa < max_tentativas - 1:
    espera = (2 ** tentativa) + random.uniform(0, 1)
    print(f"Tentativa {tentativa + 1} falhou ({response.status_code}). "
    f"Aguardando {espera:.1f}s...")
    time.sleep(espera)
    continue

    except requests.exceptions.Timeout:
    if tentativa < max_tentativas - 1:
    espera = (2 ** tentativa) + random.uniform(0, 1)
    print(f"Timeout na tentativa {tentativa + 1}. "
    f"Aguardando {espera:.1f}s...")
    time.sleep(espera)
    continue

    except requests.exceptions.ConnectionError:
    if tentativa < max_tentativas - 1:
    espera = (2 ** tentativa) + random.uniform(0, 1)
    print(f"Erro de conexão na tentativa {tentativa + 1}. "
    f"Aguardando {espera:.1f}s...")
    time.sleep(espera)
    continue

    return {"erro": "Todas as tentativas falharam", "retry": True}

# Uso
resultado = consultar_cpf_com_retry("12345678900")
print(resultado)

async function consultarCPFComRetry(cpf, maxTentativas = 3) {
    const url = `https://api.cpfhub.io/cpf/${cpf}`;
    const headers = {
    'x-api-key': 'SUA_CHAVE_DE_API',
    'Accept': 'application/json'
    };

    const codigosRetry = new Set([500, 503]);

    for (let tentativa = 0; tentativa < maxTentativas; tentativa++) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), 10000);

    try {
    const response = await fetch(url, {
    headers,
    signal: controller.signal
    });

    clearTimeout(timeoutId);

    // Sucesso
    if (response.ok) {
    return await response.json();
    }

    // Erro permanente
    if ([400, 401, 404].includes(response.status)) {
    return { erro: `Erro ${response.status}`, retry: false };
    }

    // Erro temporário
    if (codigosRetry.has(response.status)) {
    if (tentativa < maxTentativas - 1) {
    const espera = Math.pow(2, tentativa) * 1000 + Math.random() * 1000;
    console.log(
    `Tentativa ${tentativa + 1} falhou (${response.status}). ` +
    `Aguardando ${(espera / 1000).toFixed(1)}s...`
    );
    await new Promise(resolve => setTimeout(resolve, espera));
    continue;
    }
    }

    } catch (error) {
    clearTimeout(timeoutId);

    if (tentativa < maxTentativas - 1) {
    const espera = Math.pow(2, tentativa) * 1000 + Math.random() * 1000;
    const tipo = error.name === 'AbortError' ? 'Timeout' : 'Erro de conexão';
    console.log(
    `${tipo} na tentativa ${tentativa + 1}. ` +
    `Aguardando ${(espera / 1000).toFixed(1)}s...`
    );
    await new Promise(resolve => setTimeout(resolve, espera));
    continue;
    }
    }
    }

    return { erro: 'Todas as tentativas falharam', retry: true };
}

package main

import (
    "fmt"
    "io"
    "math"
    "math/rand"
    "net/http"
    "time"
)

func consultarCPFComRetry(cpf string, maxTentativas int) (string, error) {
    url := fmt.Sprintf("https://api.cpfhub.io/cpf/%s", cpf)
    codigosRetry := map[int]bool{500: true, 503: true}

    client := &http.Client{Timeout: 10 * time.Second}

    for tentativa := 0; tentativa < maxTentativas; tentativa++ {
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
    return "", err
    }

    req.Header.Set("x-api-key", "SUA_CHAVE_DE_API")
    req.Header.Set("Accept", "application/json")

    resp, err := client.Do(req)
    if err != nil {
    if tentativa < maxTentativas-1 {
    espera := math.Pow(2, float64(tentativa)) + rand.Float64()
    fmt.Printf("Erro na tentativa %d. Aguardando %.1fs...\n",
    tentativa+1, espera)
    time.Sleep(time.Duration(espera * float64(time.Second)))
    continue
    }
    return "", err
    }
    defer resp.Body.Close()

    if resp.StatusCode == 200 {
    body, _ := io.ReadAll(resp.Body)
    return string(body), nil
    }

    if codigosRetry[resp.StatusCode] && tentativa < maxTentativas-1 {
    espera := math.Pow(2, float64(tentativa)) + rand.Float64()
    fmt.Printf("Status %d na tentativa %d. Aguardando %.1fs...\n",
    resp.StatusCode, tentativa+1, espera)
    time.Sleep(time.Duration(espera * float64(time.Second)))
    continue
    }

    body, _ := io.ReadAll(resp.Body)
    return string(body), fmt.Errorf("erro HTTP %d", resp.StatusCode)
    }

    return "", fmt.Errorf("todas as %d tentativas falharam", maxTentativas)
}

func main() {
    resultado, err := consultarCPFComRetry("12345678900", 3)
    if err != nil {
    fmt.Println("Erro:", err)
    return
    }
    fmt.Println(resultado)
}