Errors

import requests

RETRYABLE = {503, 502, 429}

class SimnetError(RuntimeError):
    def __init__(self, status, message, detail):
        self.status, self.message, self.detail = status, message, detail
        super().__init__(f"{status} {message}: {detail or 'no detail'}")

def check(res: requests.Response) -> dict:
    if res.ok:
        return res.json() if res.content else {}

    # 401 carries no body at all, so never assume JSON is present.
    try:
        body = res.json()
    except ValueError:
        body = {}

    raise SimnetError(res.status_code, body.get("message", ""), body.get("detail"))

def is_retryable(err: SimnetError) -> bool:
    # 422 is a refusal, not a transient fault — retrying sends the same rejected
    # request again. Only genuine upstream problems are worth another attempt.
    return err.status in RETRYABLE

export class SimnetError extends Error {
  constructor(
    readonly status: number,
    readonly apiMessage: string,
    readonly detail: string | null,
  ) {
    super(`${status} ${apiMessage}: ${detail ?? "no detail"}`);
  }

  /** 422 is a refusal, not a transient fault — resending changes nothing. */
  get retryable(): boolean {
    return this.status === 503 || this.status === 502;
  }
}

export async function check<T>(res: Response): Promise<T> {
  if (res.ok) return (res.status === 204 ? undefined : await res.json()) as T;

  // A 401 has an empty body, so guard the parse.
  let body: { message?: string; detail?: string | null } = {};
  try {
    body = await res.json();
  } catch {
    /* empty body — status alone is the signal */
  }
  throw new SimnetError(res.status, body.message ?? "", body.detail ?? null);
}