Генерация пачками: очередь, вебхуки и ключ идемпотентности

import os
import time
from collections import deque

import requests

API = "https://api.rendergrid.io/api/public/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['RENDERGRID_API_KEY']}"}
MAX_IN_FLIGHT = 80  # с запасом до лимита в 100 заданий на аккаунт
SUBMIT_PAUSE = 1.0  # секунд между запусками: не больше 60 в минуту при лимите 120
POLL_PAUSE = 5.0  # одно задание — не чаще раза в 5 секунд

prompts = ["…", "…"]  # ваши промпты
queue = deque((f"batch-7-{n:04d}", prompt) for n, prompt in enumerate(prompts))
running = {}  # id задания -> [номер операции, когда спрашивали в последний раз]
finished = {}  # номер операции -> ответ GET /creations/{id}
next_launch = 0.0

while queue or running:
    now = time.monotonic()

    if queue and len(running) < MAX_IN_FLIGHT and now >= next_launch:
        operation, prompt = queue[0]
        next_launch = now + SUBMIT_PAUSE
        try:
            r = requests.post(
                f"{API}/images/generate",
                headers={**HEADERS, "X-Idempotency-Key": operation},
                json={
                    "model": "nano-banana-2.1",
                    "prompt": prompt,
                    "resolution": "1K",
                    "aspect_ratio": "1:1",
                },
                timeout=(5, 30),
            )
        except (requests.Timeout, requests.ConnectionError):
            r = None  # ответа нет: операция остаётся в очереди и уйдёт с тем же ключом
        if r is not None and r.status_code == 202:
            running[r.json()["id"]] = [operation, now]
            queue.popleft()
        elif r is not None and r.status_code == 429:
            next_launch = now + max(SUBMIT_PAUSE, int(r.headers.get("Retry-After", "5")))
        elif r is not None and r.status_code < 500:
            raise RuntimeError(f"HTTP {r.status_code}: {r.text}")  # 400, 402: сначала причина

    for creation_id, state in list(running.items()):
        if now - state[1] < POLL_PAUSE:
            continue
        state[1] = now
        try:
            r = requests.get(f"{API}/creations/{creation_id}", headers=HEADERS, timeout=(5, 20))
        except (requests.Timeout, requests.ConnectionError):
            continue
        if r.status_code == 429 or r.status_code >= 500:
            continue
        r.raise_for_status()
        creation = r.json()
        if creation["status"] in ("completed", "failed"):
            finished[state[0]] = creation
            del running[creation_id]

    time.sleep(0.2)

failed = [name for name, c in finished.items() if c["status"] == "failed"]
print(len(finished) - len(failed), "готово; не вышло:", failed)

// Node.js 22+, файл .mjs
const API = "https://api.rendergrid.io/api/public/v1";
const AUTH = { Authorization: `Bearer ${process.env.RENDERGRID_API_KEY}` };
const MAX_IN_FLIGHT = 80; // с запасом до лимита в 100 заданий на аккаунт
const SUBMIT_PAUSE = 1000; // мс между запусками: не больше 60 в минуту при лимите 120
const POLL_PAUSE = 5000; // одно задание — не чаще раза в 5 секунд
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
const noAnswer = (error) => error instanceof TypeError || error.name === "TimeoutError";

const prompts = ["…", "…"]; // ваши промпты
const queue = prompts.map((prompt, n) => ({
  operation: `batch-7-${String(n).padStart(4, "0")}`,
  prompt,
}));
const running = new Map(); // id задания -> { operation, polledAt }
const finished = new Map(); // номер операции -> ответ GET /creations/{id}
let nextLaunch = 0;

while (queue.length || running.size) {
  const now = Date.now();

  if (queue.length && running.size < MAX_IN_FLIGHT && now >= nextLaunch) {
    const { operation, prompt } = queue[0];
    nextLaunch = now + SUBMIT_PAUSE;
    let response = null;
    try {
      response = await fetch(`${API}/images/generate`, {
        method: "POST",
        headers: { ...AUTH, "Content-Type": "application/json", "X-Idempotency-Key": operation },
        body: JSON.stringify({
          model: "nano-banana-2.1",
          prompt,
          resolution: "1K",
          aspect_ratio: "1:1",
        }),
        signal: AbortSignal.timeout(30_000),
      });
    } catch (error) {
      // ответа нет: операция остаётся в очереди и уйдёт с тем же ключом
      if (!noAnswer(error)) throw error;
    }
    if (response?.status === 202) {
      running.set((await response.json()).id, { operation, polledAt: now });
      queue.shift();
    } else if (response?.status === 429) {
      const wait = Number(response.headers.get("Retry-After") ?? 5);
      nextLaunch = now + Math.max(SUBMIT_PAUSE, wait * 1000);
    } else if (response && response.status < 500) {
      throw new Error(`HTTP ${response.status}: ${await response.text()}`); // 400, 402: сначала причина
    }
  }

  for (const [id, state] of [...running]) {
    if (now - state.polledAt < POLL_PAUSE) continue;
    state.polledAt = now;
    let response;
    try {
      response = await fetch(`${API}/creations/${id}`, {
        headers: AUTH,
        signal: AbortSignal.timeout(20_000),
      });
    } catch (error) {
      if (!noAnswer(error)) throw error;
      continue;
    }
    if (response.status === 429 || response.status >= 500) continue;
    if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
    const creation = await response.json();
    if (creation.status === "completed" || creation.status === "failed") {
      finished.set(state.operation, creation);
      running.delete(id);
    }
  }

  await sleep(200);
}

const failed = [...finished].filter(([, c]) => c.status === "failed").map(([name]) => name);
console.log(finished.size - failed.length, "готово; не вышло:", failed);

import hashlib
import hmac
import json
import os
import re
import time
from http.server import BaseHTTPRequestHandler, HTTPServer

SECRET = os.environ["RENDERGRID_WEBHOOK_SECRET"]  # секрет подписи из кабинета
TOLERANCE_SECONDS = 300


def signature_ok(timestamp, raw_body, signature):
    if not re.fullmatch(r"[0-9]{1,12}", timestamp or ""):
        return False
    if not re.fullmatch(r"sha256=[0-9a-f]{64}", signature or ""):
        return False
    if abs(time.time() - int(timestamp)) > TOLERANCE_SECONDS:
        return False
    expected = "sha256=" + hmac.new(
        SECRET.encode("utf-8"),
        timestamp.encode("ascii") + b"." + raw_body,
        hashlib.sha256,
    ).hexdigest()
    return hmac.compare_digest(expected, signature)


class Hook(BaseHTTPRequestHandler):
    def do_POST(self):
        raw_body = self.rfile.read(int(self.headers.get("Content-Length", "0")))
        if not signature_ok(
            self.headers.get("X-Timestamp"),
            raw_body,
            self.headers.get("X-Webhook-Signature-256"),
        ):
            self.send_response(400)
            self.end_headers()
            return
        event = json.loads(raw_body)
        # сначала сохраняем, потом отвечаем; дубли убирает обработчик по паре (id, event)
        with open("events.jsonl", "a", encoding="utf-8") as out:
            out.write(json.dumps(event, ensure_ascii=False) + "\n")
        self.send_response(200)
        self.end_headers()


HTTPServer(("", 8080), Hook).serve_forever()

// Node.js 22+, файл .mjs
import { createHmac, timingSafeEqual } from "node:crypto";
import { appendFileSync } from "node:fs";
import { createServer } from "node:http";

const SECRET = process.env.RENDERGRID_WEBHOOK_SECRET; // секрет подписи из кабинета
const TOLERANCE_SECONDS = 300;

function signatureOk(timestamp, rawBody, signature) {
  if (typeof timestamp !== "string" || !/^[0-9]{1,12}$/.test(timestamp)) return false;
  if (typeof signature !== "string" || !/^sha256=[0-9a-f]{64}$/.test(signature)) return false;
  if (Math.abs(Date.now() / 1000 - Number(timestamp)) > TOLERANCE_SECONDS) return false;
  const expected =
    "sha256=" +
    createHmac("sha256", Buffer.from(SECRET, "utf8"))
      .update(timestamp + ".", "ascii")
      .update(rawBody)
      .digest("hex");
  return timingSafeEqual(Buffer.from(expected, "ascii"), Buffer.from(signature, "ascii"));
}

createServer((req, res) => {
  const chunks = [];
  req.on("data", (chunk) => chunks.push(chunk));
  req.on("end", () => {
    const rawBody = Buffer.concat(chunks);
    const timestamp = req.headers["x-timestamp"];
    const signature = req.headers["x-webhook-signature-256"];
    if (!signatureOk(timestamp, rawBody, signature)) {
      res.writeHead(400).end();
      return;
    }
    const event = JSON.parse(rawBody.toString("utf8"));
    // сначала сохраняем, потом отвечаем; дубли убирает обработчик по паре (id, event)
    appendFileSync("events.jsonl", JSON.stringify(event) + "\n");
    res.writeHead(200).end();
  });
}).listen(8080);

# Одна операция — один ключ; запрос ушёл дважды, например после обрыва связи
for attempt in 1 2; do
  curl --fail-with-body --max-time 30 \
    -X POST https://api.rendergrid.io/api/public/v1/images/generate \
    -H "Authorization: Bearer $RENDERGRID_API_KEY" \
    -H "Content-Type: application/json" \
    -H "X-Idempotency-Key: batch-7-0001" \
    -d '{
      "model": "nano-banana-2.1",
      "prompt": "Белый тюбик на персиковом постаменте, мягкий свет слева",
      "resolution": "1K"
    }'
  echo
done

import os
import random
import time

import requests

URL = "https://api.rendergrid.io/api/public/v1/images/generate"
HEADERS = {"Authorization": f"Bearer {os.environ['RENDERGRID_API_KEY']}"}


def submit(payload, operation, attempts=3):
    for attempt in range(attempts):
        delay = 2 ** (attempt + 1) + random.random()
        try:
            r = requests.post(
                URL,
                headers={**HEADERS, "X-Idempotency-Key": operation},
                json=payload,
                timeout=(5, 30),
            )
        except (requests.Timeout, requests.ConnectionError):
            r = None  # ответа нет, но запрос мог дойти: повторяем с тем же ключом
        if r is not None:
            if r.status_code == 202:
                return r.json()
            if r.status_code != 429 and r.status_code < 500:
                raise RuntimeError(f"HTTP {r.status_code}: {r.text}")  # сначала причина
            wait = r.headers.get("Retry-After", "")
            if wait.isascii() and wait.isdigit():
                delay = max(delay, int(wait))
        if attempt + 1 < attempts:
            time.sleep(delay)
    raise RuntimeError("запрос не принят: проверьте историю запросов, а не берите новый ключ")


creation = submit(
    {
        "model": "nano-banana-2.1",
        "prompt": "Белый тюбик на персиковом постаменте, мягкий свет слева",
        "resolution": "1K",
    },
    operation="batch-7-0001",
)
print(creation["id"])

// Node.js 22+, файл .mjs
const ENDPOINT = "https://api.rendergrid.io/api/public/v1/images/generate";
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function submit(payload, operation, attempts = 3) {
  for (let attempt = 0; attempt < attempts; attempt++) {
    let delay = (2 ** (attempt + 1) + Math.random()) * 1000;
    let response = null;
    try {
      response = await fetch(ENDPOINT, {
        method: "POST",
        headers: {
          Authorization: `Bearer ${process.env.RENDERGRID_API_KEY}`,
          "Content-Type": "application/json",
          "X-Idempotency-Key": operation,
        },
        body: JSON.stringify(payload),
        signal: AbortSignal.timeout(30_000),
      });
    } catch (error) {
      // ответа нет, но запрос мог дойти: повторяем с тем же ключом
      if (!(error instanceof TypeError) && error.name !== "TimeoutError") throw error;
    }
    if (response) {
      if (response.status === 202) return response.json();
      if (response.status !== 429 && response.status < 500) {
        throw new Error(`HTTP ${response.status}: ${await response.text()}`); // сначала причина
      }
      const wait = response.headers.get("Retry-After");
      if (wait && /^[0-9]+$/.test(wait)) delay = Math.max(delay, Number(wait) * 1000);
    }
    if (attempt + 1 < attempts) await sleep(delay);
  }
  throw new Error("запрос не принят: проверьте историю запросов, а не берите новый ключ");
}

const creation = await submit(
  {
    model: "nano-banana-2.1",
    prompt: "Белый тюбик на персиковом постаменте, мягкий свет слева",
    resolution: "1K",
  },
  "batch-7-0001",
);
console.log(creation.id);