批量生成图片：队列、Webhook 与幂等键

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  # 两次启动之间隔 1 秒：每分钟最多 60 次，低于 120 次的限额
POLL_PAUSE = 5.0  # 同一个任务两次查询之间至少隔 5 秒
MAX_ATTEMPTS = 5  # 一个操作最多发送几次


def retry_after(response, default=5):
    value = response.headers.get("Retry-After", "")
    return int(value) if value.isascii() and value.isdigit() else default


prompts = ["……", "……"]  # 你的提示词
queue = deque((f"batch-7-{n:04d}", prompt) for n, prompt in enumerate(prompts))
failures = {}  # 操作编号 -> 没有得到结果的尝试次数
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, retry_after(r))
        elif r is not None and r.status_code < 500:
            raise RuntimeError(f"HTTP {r.status_code}: {r.text}")  # 400、401、402、403、404：先排除原因
        else:
            failures[operation] = failures.get(operation, 0) + 1
            if failures[operation] >= MAX_ATTEMPTS:
                raise RuntimeError(f"{operation}: 多次没有得到结果，请先查看请求记录")

    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 MAX_ATTEMPTS = 5; // 一个操作最多发送几次
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
const noAnswer = (error) => error instanceof TypeError || error.name === "TimeoutError";
const retryAfter = (response, fallback = 5) => {
  const value = response.headers.get("Retry-After");
  return value && /^[0-9]+$/.test(value) ? Number(value) : fallback;
};

const prompts = ["……", "……"]; // 你的提示词
const queue = prompts.map((prompt, n) => ({
  operation: `batch-7-${String(n).padStart(4, "0")}`,
  prompt,
}));
const failures = new Map(); // 操作编号 -> 没有得到结果的尝试次数
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) {
      nextLaunch = now + Math.max(SUBMIT_PAUSE, retryAfter(response) * 1000);
    } else if (response && response.status < 500) {
      // 400、401、402、403、404：先排除原因
      throw new Error(`HTTP ${response.status}: ${await response.text()}`);
    } else {
      const count = (failures.get(operation) ?? 0) + 1;
      failures.set(operation, count);
      if (count >= MAX_ATTEMPTS) throw new Error(`${operation}: 多次没有得到结果，请先查看请求记录`);
    }
  }

  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"]  # 控制台里的签名密钥，完整保存，包括 whsec_
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; // 控制台里的签名密钥，完整保存，包括 whsec_
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);
    if (
      !signatureOk(req.headers["x-timestamp"], rawBody, req.headers["x-webhook-signature-256"])
    ) {
      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);