Error Handling

{
  "errors": [
    {
      "code": "invalid_file_type",
      "message": "Unsupported file type: application/octet-stream",
      "suggestion": "Supported types: image/jpeg, image/png, video/mp4, text/csv, text/plain, application/json",
      "error_uid": "err-bfa600db-c703-4061-ad9c-c14628b3554c"
    }
  ]
}

import time
import random
import requests

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

def make_request_with_retry(url, headers, max_retries=3):
    for attempt in range(max_retries):
        response = requests.get(url, headers=headers)

        if response.ok:
            return response.json()

        # Pull whatever identifying info we can out of the body. Most endpoints
        # use the plural `errors` array; some legacy paths use `{"detail": ...}`.
        code = None
        error_uid = None
        try:
            body = response.json()
            if isinstance(body.get("errors"), list) and body["errors"]:
                code = body["errors"][0].get("code")
                error_uid = body["errors"][0].get("error_uid")
            elif "detail" in body:
                code = "detail"  # legacy envelope
        except ValueError:
            pass

        if response.status_code not in TRANSIENT_STATUSES:
            # 4xx other than 429 — don't retry, surface the error.
            response.raise_for_status()

        wait_time = (2 ** attempt) + random.uniform(0, 1)
        print(
            f"Transient {response.status_code} (code={code}, "
            f"error_uid={error_uid}). Retrying in {wait_time:.2f}s..."
        )
        time.sleep(wait_time)

    raise Exception(f"Max retries ({max_retries}) exceeded")

# Usage
try:
    data = make_request_with_retry(
        "https://api.u1.archetypeai.app/v0.5/lens/info",
        {"Authorization": "Bearer YOUR_API_KEY"},
    )
    print(data)
except Exception as e:
    print(f"Request failed after retries: {e}")

import logging
import requests

logger = logging.getLogger(__name__)

def log_api_error(response: requests.Response, method: str, url: str) -> None:
    try:
        body = response.json()
        errors = body.get("errors") or []
    except ValueError:
        body, errors = None, []

    primary = errors[0] if errors else {}
    logger.error(
        "Newton API error",
        extra={
            "status_code": response.status_code,
            "error_code": primary.get("code"),
            "error_uid": primary.get("error_uid"),
            "request_method": method,
            "request_url": url,
            "response_body": body if body is not None else response.text,
        },
    )

# Usage
response = requests.get(url, headers=headers)
if not response.ok:
    log_api_error(response, "GET", url)
    response.raise_for_status()