Como fazer fallback automático quando a API de CPF está fora do ar

import requests
import redis
import json

redis_client = redis.Redis(host='localhost', port=6379, db=0)
CACHE_TTL = 86400 # 24 horas

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

    # Tentar consulta na API
    try:
    response = requests.get(url, headers=headers, timeout=10)

    if response.status_code == 200:
    dados = response.json()

    # Armazenar no cache para uso futuro como fallback
    if dados.get("success"):
    redis_client.setex(
    f"cpf_fallback:{cpf}",
    CACHE_TTL,
    json.dumps(dados)
    )

    return {"fonte": "api", "dados": dados}

    except (requests.exceptions.Timeout,
    requests.exceptions.ConnectionError):
    pass

    # Fallback: tentar cache
    cached = redis_client.get(f"cpf_fallback:{cpf}")
    if cached:
    dados = json.loads(cached)
    return {"fonte": "cache", "dados": dados, "aviso": "Dados do cache"}

    # Nenhum fallback disponível
    return {
    "fonte": "nenhum",
    "erro": "API indisponível e sem cache para este CPF"
    }

function validarCPFSintatico(cpf) {
    cpf = cpf.replace(/\D/g, '');
    if (cpf.length !== 11) return false;
    if (/^(\d)\1{10}$/.test(cpf)) return false;

    let soma = 0;
    for (let i = 0; i < 9; i++) soma += parseInt(cpf[i]) * (10 - i);
    let resto = (soma * 10) % 11;
    if (resto === 10) resto = 0;
    if (resto !== parseInt(cpf[9])) return false;

    soma = 0;
    for (let i = 0; i < 10; i++) soma += parseInt(cpf[i]) * (11 - i);
    resto = (soma * 10) % 11;
    if (resto === 10) resto = 0;
    return resto === parseInt(cpf[10]);
}

async function consultarCPFComFallback(cpf) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), 10000);

    try {
    const response = await fetch(
    `https://api.cpfhub.io/cpf/${cpf}`,
    {
    headers: {
    'x-api-key': 'SUA_CHAVE_DE_API',
    'Accept': 'application/json'
    },
    signal: controller.signal
    }
    );

    clearTimeout(timeoutId);

    if (response.ok) {
    return { fonte: 'api', dados: await response.json() };
    }

    throw new Error(`HTTP ${response.status}`);

    } catch (error) {
    clearTimeout(timeoutId);

    // Fallback: validação sintática
    const sintaticamenteValido = validarCPFSintatico(cpf);

    return {
    fonte: 'fallback_sintatico',
    valido: sintaticamenteValido,
    aviso: 'Validação real indisponível. Apenas formato verificado.',
    revalidarDepois: true
    };
    }
}

import requests
import redis
import json
from datetime import datetime

redis_client = redis.Redis(host='localhost', port=6379, db=0)

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

    try:
    response = requests.get(url, headers=headers, timeout=10)

    if response.status_code == 200:
    return {
    "status": "validado",
    "dados": response.json()
    }

    except (requests.exceptions.Timeout,
    requests.exceptions.ConnectionError):
    pass

    # API indisponível: enfileirar para revalidação
    item_fila = {
    "cpf": cpf,
    "dados_cadastro": dados_cadastro,
    "enfileirado_em": datetime.now().isoformat(),
    "tentativas": 0
    }

    redis_client.rpush("fila_revalidacao_cpf", json.dumps(item_fila))

    return {
    "status": "pendente",
    "aviso": "CPF será validado assim que o serviço estiver disponível"
    }

def processar_fila_revalidacao():
    """Executar periodicamente (cron job ou worker)"""
    while True:
    item_raw = redis_client.lpop("fila_revalidacao_cpf")
    if not item_raw:
    break

    item = json.loads(item_raw)
    cpf = item["cpf"]

    url = f"https://api.cpfhub.io/cpf/{cpf}"
    headers = {
    "x-api-key": "SUA_CHAVE_DE_API",
    "Accept": "application/json"
    }

    try:
    response = requests.get(url, headers=headers, timeout=10)

    if response.status_code == 200:
    dados = response.json()
    print(f"CPF {cpf} revalidado: {dados}")
    # Atualizar cadastro no banco de dados
    continue

    except Exception:
    pass

    # Falhou novamente: recolocar na fila
    item["tentativas"] += 1
    if item["tentativas"] < 10:
    redis_client.rpush("fila_revalidacao_cpf", json.dumps(item))
    else:
    print(f"CPF {cpf}: máximo de tentativas atingido")

def consultar_cpf_resiliente(cpf, dados_cadastro=None):
    # Tentativa 1: API em tempo real
    try:
    resultado_api = consultar_via_api(cpf)
    if resultado_api:
    return {"fonte": "api", "dados": resultado_api}
    except Exception:
    pass

    # Tentativa 2: Cache local
    resultado_cache = buscar_no_cache(cpf)
    if resultado_cache:
    return {"fonte": "cache", "dados": resultado_cache}

    # Tentativa 3: Validação sintática + fila
    sintaticamente_valido = validar_cpf_sintatico(cpf)
    if sintaticamente_valido and dados_cadastro:
    enfileirar_para_revalidacao(cpf, dados_cadastro)
    return {
    "fonte": "sintatico",
    "valido_formato": True,
    "pendente_validacao_real": True
    }

    # Tentativa 4: Rejeição
    return {
    "fonte": "nenhum",
    "valido": False,
    "motivo": "CPF inválido e serviço indisponível"
    }