Handle API errors

import os
import random
import time

import requests

BASE_URL = "https://client-api.leak.center"
MESSAGE_KEYS = ("detail", "error_message", "details", "error", "message")


class DarknetSearchError(Exception):
    def __init__(self, status, body):
        self.status = status
        self.body = body
        message = next((body[key] for key in MESSAGE_KEYS if key in body), body)
        super().__init__(f"HTTP {status}: {message}")


def is_retryable(method, status, body):
    if status == 429:
        return body.get("retry_after_seconds") == 1  # per-second rate limit only
    return method == "GET" and status in (500, 502, 503, 504)


def call(method, path, attempts=5, **kwargs):
    headers = {"X-API-Key": os.environ["DARKNETSEARCH_API_KEY"]}
    for attempt in range(1, attempts + 1):
        response = requests.request(method, BASE_URL + path, headers=headers, timeout=120, **kwargs)
        if response.ok:
            return response
        try:
            body = response.json()
        except ValueError:
            body = response.text
        if not isinstance(body, dict):
            body = {"detail": body}
        if attempt == attempts or not is_retryable(method, response.status_code, body):
            raise DarknetSearchError(response.status_code, body)
        delay = float(response.headers.get("Retry-After", 2 ** attempt))
        time.sleep(delay + random.random())


try:
    call("POST", "/api/service/create_infra_search_request/", json={"search_term": "acme.com"})
except DarknetSearchError as error:
    if error.status == 429 and "resource" in error.body:
        print(f"The {error.body['resource']} allowance is spent for this {error.body['period']}.")
    else:
        raise

const BASE_URL = "https://client-api.leak.center";
const MESSAGE_KEYS = ["detail", "error_message", "details", "error", "message"];

class DarknetSearchError extends Error {
  constructor(status, body) {
    const key = MESSAGE_KEYS.find((name) => name in body);
    super(`HTTP ${status}: ${JSON.stringify(key ? body[key] : body)}`);
    this.status = status;
    this.body = body;
  }
}

function isRetryable(method, status, body) {
  if (status === 429) return body.retry_after_seconds === 1; // per-second rate limit only
  return method === "GET" && [500, 502, 503, 504].includes(status);
}

async function call(method, path, { attempts = 5, ...init } = {}) {
  const headers = { "X-API-Key": process.env.DARKNETSEARCH_API_KEY, ...init.headers };
  for (let attempt = 1; ; attempt++) {
    const response = await fetch(BASE_URL + path, { ...init, method, headers });
    if (response.ok) return response;
    const text = await response.text();
    let body;
    try {
      body = JSON.parse(text);
    } catch {
      body = text;
    }
    if (body === null || typeof body !== "object" || Array.isArray(body)) body = { detail: body };
    if (attempt === attempts || !isRetryable(method, response.status, body)) {
      throw new DarknetSearchError(response.status, body);
    }
    const delay = Number(response.headers.get("Retry-After") ?? 2 ** attempt);
    await new Promise((resolve) => setTimeout(resolve, (delay + Math.random()) * 1000));
  }
}