Errors

import { randomUUID } from 'node:crypto';

export class SlicerError extends Error {
  constructor(status, error) {
    super(`${status} ${error.code}: ${error.message}`);
    this.status = status;
    this.code = error.code;
    this.fields = error.fields;
    this.retryAfterSec = error.retryAfterSec;
  }
}

const RETRYABLE = new Set([429, 500, 502, 503, 504]);
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

/** API request with retries: one Idempotency-Key for all attempts. */
export async function slicer(method, path, body, { attempts = 5 } = {}) {
  const key = method === 'POST' ? randomUUID() : undefined;
  for (let attempt = 1; ; attempt += 1) {
    let response;
    try {
      response = await fetch(`https://api.slicer.media/v1${path}`, {
        method,
        headers: {
          Authorization: `Bearer ${process.env.SLICER_TOKEN}`,
          ...(body ? { 'Content-Type': 'application/json' } : {}),
          ...(key ? { 'Idempotency-Key': key } : {}),
        },
        body: body ? JSON.stringify(body) : undefined,
      });
    } catch (networkError) {
      if (attempt >= attempts) throw networkError;
      await sleep(2 ** attempt * 500);
      continue;
    }
    const json = await response.json();
    if (json.ok) return json.data;
    const retry = RETRYABLE.has(response.status) || json.error.code === 'request_in_progress';
    if (!retry || attempt >= attempts) throw new SlicerError(response.status, json.error);
    const wait = Number(response.headers.get('Retry-After')) || 2 ** attempt * 0.5;
    await sleep(wait * 1000);
  }
}

import os
import time
import uuid

import requests

RETRYABLE = {429, 500, 502, 503, 504}


class SlicerError(Exception):
    def __init__(self, status, error):
        super().__init__(f"{status} {error['code']}: {error['message']}")
        self.status = status
        self.code = error["code"]
        self.fields = error.get("fields")


def slicer(method, path, json=None, attempts=5):
    """API request with retries: one Idempotency-Key for all attempts."""
    headers = {"Authorization": f"Bearer {os.environ['SLICER_TOKEN']}"}
    if method == "POST":
        headers["Idempotency-Key"] = str(uuid.uuid4())
    for attempt in range(1, attempts + 1):
        try:
            response = requests.request(
                method, f"https://api.slicer.media/v1{path}", json=json, headers=headers, timeout=60
            )
        except requests.ConnectionError:
            if attempt == attempts:
                raise
            time.sleep(2 ** attempt * 0.5)
            continue
        body = response.json()
        if body["ok"]:
            return body["data"]
        error = body["error"]
        retry = response.status_code in RETRYABLE or error["code"] == "request_in_progress"
        if not retry or attempt == attempts:
            raise SlicerError(response.status_code, error)
        time.sleep(float(response.headers.get("Retry-After") or 2 ** attempt * 0.5))