Async results and polling

def get_result(submit, poll_url, api_key, attempts=3):
    """Submit, poll, and submit again when the job is lost.

    Returns the finished `data`, or None when it is not worth asking again.
    """
    session = requests.Session()
    session.headers["X-Api-Key"] = api_key

    for _ in range(attempts):
        job_id = submit()
        time.sleep(3)                    # a new id is not queryable at once
        start = time.monotonic()

        while True:
            response = session.get(poll_url(job_id), timeout=30)
            waited = time.monotonic() - start

            if response.status_code == 404:
                if waited < 10:
                    time.sleep(2)        # not ready yet, not lost
                    continue
                break                    # the job is gone, submit it again

            if response.status_code == 429 or response.status_code >= 500:
                time.sleep(5)            # Miso is busy
                continue

            data = response.json()["data"]

            if not data["finished"]:
                if waited > 180:
                    break                # lost, submit it again
                time.sleep(2)
                continue

            if data["finish_reason"] == "success":
                return data              # accept it, even when empty
            if data["finish_reason"] == "error":
                break                    # a fault, submit it again
            return None                  # forbidden, read blocked_reason

    return None                          # out of attempts

// Submit, poll, and submit again when the job is lost.
// Returns the finished `data`, or null when it is not worth asking again.
async function getResult(submit, pollUrl, apiKey, attempts = 3) {
  const wait = (ms) => new Promise((r) => setTimeout(r, ms));

  for (let attempt = 0; attempt < attempts; attempt++) {
    const jobId = await submit();
    await wait(3000);                  // a new id is not queryable at once
    const start = Date.now();
    let lost = false;

    while (!lost) {
      const response = await fetch(pollUrl(jobId), {
        headers: { "X-Api-Key": apiKey },
      });
      const waited = Date.now() - start;

      if (response.status === 404) {
        if (waited < 10_000) { await wait(2000); continue; }  // not ready yet
        lost = true; continue;         // the job is gone, submit it again
      }
      if (response.status === 429 || response.status >= 500) {
        await wait(5000);              // Miso is busy
        continue;
      }

      const { data } = await response.json();

      if (!data.finished) {
        if (waited > 180_000) { lost = true; continue; }      // submit again
        await wait(2000);
        continue;
      }

      if (data.finish_reason === "success") return data;      // even when empty
      if (data.finish_reason === "error") { lost = true; continue; }
      return null;                     // forbidden, read data.blocked_reason
    }
  }
  return null;                         // out of attempts
}

# Submit, poll, and submit again when the job is lost.
# Prints the finished `data`. Exit 1 means it is not worth asking again.
get_result() {                       # get_result <submit-cmd> <poll-url-prefix>
  local attempt job_id waited start status out=$(mktemp)

  for attempt in 1 2 3; do
    job_id=$($1)                     # your submit command prints the new id
    sleep 3                          # a new id is not queryable at once
    start=$SECONDS

    while :; do
      status=$(curl -sS -o "$out" -w '%{http_code}' -H "X-Api-Key: $KEY" "$2/$job_id")
      waited=$(( SECONDS - start ))

      case $status in
        404) (( waited < 10 )) && { sleep 2; continue; }      # not ready yet
             break ;;                                          # gone, submit again
        429|5??) sleep 5; continue ;;                         # Miso is busy
      esac

      if [ "$(jq -r .data.finished "$out")" != true ]; then
        (( waited > 180 )) && break                           # lost, submit again
        sleep 2; continue
      fi

      case $(jq -r .data.finish_reason "$out") in
        success) jq .data "$out"; return 0 ;;                 # even when empty
        error)   break ;;                                     # submit again
        *)       return 1 ;;                                  # forbidden
      esac
    done
  done
  return 1                                                    # out of attempts
}