Authentication

import { ISnapClient } from '@isnap/sdk'

// The client sends the Authorization header on every request. It retries a failed
// connection, a 500 or a 503 with backoff, and a 429 whose delay is 60 seconds or
// less, except a QuotaExceededError: up to 2 retries. It adds an Idempotency-Key to
// every write and reuses it on its retries.
export const client = new ISnapClient({
  apiKey: process.env.ISNAP_API_KEY ?? '',
  maxRetries: 2
})

// Pass as the last argument of a write on an operation that does not honor
// Idempotency-Key, of chats.shareContactCard and of trial.status, so that a
// retry cannot run the operation twice:
//   await client.webhooks.create(body, noRetry)
export const noRetry = { maxRetries: 0 }

import os
import time

import requests

BASE_URL = "https://api.isnap.ai"
MAX_RETRIES = 2
MAX_WAIT_SECONDS = 60


class ISnapError(Exception):
    """An error response of the iSnap API."""

    def __init__(self, status, body):
        body = body if isinstance(body, dict) else {}
        error = body.get("error")
        error = error if isinstance(error, dict) else {}
        self.status = status
        self.code = error.get("code")
        self.message = error.get("message")
        self.retry_after = error.get("retry_after")
        self.issues = error.get("issues")
        self.trace_id = body.get("trace_id")
        self.request_id = body.get("request_id")
        super().__init__(
            f"{status} {self.code}: {self.message} "
            f"(trace_id={self.trace_id}, request_id={self.request_id})"
        )


def isnap_request(method, path, *, params=None, json=None, idempotency_key=None, api_key=None):
    """Call the iSnap API. Return the `data` of the response, or None on a 204.

    Pass `idempotency_key` only to an operation that honors Idempotency-Key: the helper then
    retries with the same key. Do not use this helper for
    `POST /v1/chats/{chat_id}/share-contact-card`: send that call once, with a key, and look
    for the message before you resend it. Do not use it for `GET /v1/trial/status` either:
    the first read within 1 hour after pairing returns the trial key, and no later read
    returns it.
    """
    headers = {"Authorization": f"Bearer {api_key or os.environ['ISNAP_API_KEY']}"}
    if idempotency_key is not None:
        headers["Idempotency-Key"] = idempotency_key
    # A 500, a 503 or a missing response is retried on a read, and on a write only
    # with an idempotency key.
    retry_server_errors = method.upper() == "GET" or idempotency_key is not None
    retries = 0
    while True:
        try:
            response = requests.request(
                method, BASE_URL + path, params=params, json=json, headers=headers, timeout=30
            )
        except (requests.ConnectionError, requests.Timeout):
            # No response: the request may have run. Retry a read, or a write with a key.
            if not retry_server_errors or retries == MAX_RETRIES:
                raise
            time.sleep(2**retries)
            retries += 1
            continue
        if response.status_code == 204:
            return None
        try:
            body = response.json()
        except ValueError:
            body = {}
        if 200 <= response.status_code < 300:
            return body["data"]
        delay = None
        if response.status_code == 429:
            # A 429 was refused before it ran. Longer waits are left to the caller.
            retry_after = response.headers.get("Retry-After")
            if retry_after is not None and int(retry_after) <= MAX_WAIT_SECONDS:
                delay = int(retry_after)
        elif response.status_code in (500, 503) and retry_server_errors:
            delay = 2**retries
        if delay is None or retries == MAX_RETRIES:
            raise ISnapError(response.status_code, body)
        time.sleep(delay)
        retries += 1