Nano Banana Pro RESOURCE_EXHAUSTED 해결: 429 재시도와 이미지 작업 복구

[
  {"id": "banner-01", "prompt": "봄 정원의 꽃과 나무를 담은 16:9 수채화 이미지를 생성해 주세요."},
  {"id": "banner-02", "prompt": "밤하늘과 작은 등대를 담은 16:9 수채화 이미지를 생성해 주세요."}
]

python -m pip install requests Pillow
python recover.py jobs.json

import base64, hashlib, io, json, os, queue, re, sys, threading, time
from email.utils import parsedate_to_datetime
from pathlib import Path
import requests
from PIL import Image

MODEL = 'gemini-3-pro-image'
URL = f'https://generativelanguage.googleapis.com/v1beta/models/{MODEL}:generateContent'
MAX_ATTEMPTS, BUDGET, CALL_TIMEOUT = 5, 180.0, 60.0

def payload(prompt):
    return {'contents': [{'role': 'user', 'parts': [{'text': prompt}]}],
            'generationConfig': {'responseModalities': ['TEXT', 'IMAGE'],
                                 'imageConfig': {'aspectRatio': '16:9', 'imageSize': '1K'}}}

def stop_reason(status, body):
    err = body.get('error', {})
    if status not in (429, 503):
        return f'HTTP {status}: 수동 확인'
    for d in err.get('details', []):
        if str(d.get('@type', '')).endswith('QuotaFailure'):
            for v in d.get('violations', []):
                if v.get('serviceDisabled') is True:
                    return '서비스 비활성'
                if 'quotaValue' in v and str(v['quotaValue']) in ('0', '0.0'):
                    return '명시적 한도 0'
                text = ' '.join(str(v.get(k, '')) for k in
                                ('quotaMetric', 'quotaId', 'description'))
                if re.search(r'per.?day|daily|\bRPD\b', text, re.I):
                    return '일일 한도'
    message = str(err.get('message', ''))
    if re.search(r'limit\s*:\s*0(?:\D|$)|daily|per.?day|billing|payment|credits', message, re.I):
        return '한도 또는 결제 상태 확인'
    return None

def server_floor(headers, body, now):
    waits = [0.0]
    value = next((v for k, v in headers.items() if k.lower() == 'retry-after'), '')
    try:
        waits.append(float(value) if str(value).isdigit() else
                     parsedate_to_datetime(value).timestamp() - now)
    except (ValueError, TypeError, OverflowError):
        pass
    for d in body.get('error', {}).get('details', []):
        if str(d.get('@type', '')).endswith('RetryInfo'):
            m = re.fullmatch(r'(\d+(?:\.\d+)?)s', str(d.get('retryDelay', '')))
            if m:
                waits.append(float(m[1]))
    return max(waits)

def image_bytes(body):
    for c in body.get('candidates', []):
        for p in c.get('content', {}).get('parts', []):
            b = p.get('inlineData', {})
            if b.get('mimeType') not in ('image/png', 'image/jpeg', 'image/webp'):
                continue
            raw = base64.b64decode(b.get('data', ''), validate=True)
            with Image.open(io.BytesIO(raw)) as im:
                im.load()
                if im.width < 1 or im.height < 1:
                    raise ValueError('빈 이미지')
                out = io.BytesIO()
                im.convert('RGB').save(out, format='PNG')
                return out.getvalue()
    raise ValueError('이미지 없음: promptFeedback와 finishReason 확인')

def send(body, timeout):
    # 전체 POST/본문 수신에 대한 로컬 마감. 만료된 요청은 재전송하지 않습니다.
    result = queue.Queue()
    def worker():
        try:
            key = os.environ['GEMINI_API_KEY']
            with requests.Session() as session:
                r = session.post(URL, headers={'x-goog-api-key': key}, json=body,
                                 timeout=timeout, allow_redirects=False)
                result.put((r.status_code, dict(r.headers), r.json()))
        except Exception as e:
            result.put(e)
    threading.Thread(target=worker, daemon=True).start()
    try:
        value = result.get(timeout=timeout)
    except queue.Empty:
        raise TimeoutError('POST 결과 불명')
    if isinstance(value, Exception):
        raise value
    return value

def recover(record, body, destination, save, transport=send,
            clock=time.monotonic, wall=time.time, sleep=time.sleep):
    started = clock()
    initial = record.get('used', 0.0)
    def checkpoint(status, **fields):
        record.update(status=status, used=initial + clock() - started, **fields)
        save()
    if record.get('status') == 'inflight':
        checkpoint('unknown', reason='이전 POST 결과 불명')
    if record.get('status') in ('unknown', 'stopped', 'review', 'done'):
        return
    while record.get('attempts', 0) < MAX_ATTEMPTS:
        remaining = BUDGET - initial - (clock() - started)
        delay = max(0.0, record.get('notBefore', 0.0) - wall())
        if remaining <= delay + 0.05:
            checkpoint('deferred', reason='누적 시간 예산 부족')
            return
        if delay:
            sleep(delay)
        remaining = BUDGET - initial - (clock() - started)
        checkpoint('inflight', attempts=record.get('attempts', 0) + 1)
        remaining = BUDGET - initial - (clock() - started)
        if remaining <= 0:
            checkpoint('deferred', reason='호출 전 시간 예산 소진')
            return
        try:
            status, headers, response = transport(body, min(CALL_TIMEOUT, remaining))
        except Exception:
            checkpoint('unknown', reason='POST 또는 응답 수신 결과 불명')
            return
        if status == 200:
            try:
                raw = image_bytes(response)
                temp = destination.with_suffix('.tmp')
                temp.write_bytes(raw)
                os.replace(temp, destination)
                checkpoint('done', sha256=hashlib.sha256(raw).hexdigest(),
                           file=str(destination), responseId=response.get('responseId'))
            except Exception:
                checkpoint('review', reason='응답 또는 이미지 저장 확인 필요',
                           promptFeedback=response.get('promptFeedback'),
                           finishReasons=[c.get('finishReason') for c in response.get('candidates', [])])
            return
        reason = stop_reason(status, response)
        if reason:
            checkpoint('stopped', reason=reason, error=response.get('error'))
            return
        # jitter는 서버 minimum 뒤에 더합니다. minimum을 상한으로 자르지 않습니다.
        delay = max(server_floor(headers, response, wall()),
                    min(16.0, 2 ** (record['attempts'] - 1))) + __import__('random').random()
        checkpoint('pending', notBefore=wall() + delay, reason=f'HTTP {status}')
    checkpoint('stopped', reason='총 시도 횟수 소진')

def main():
    jobs = json.loads(Path(sys.argv[1]).read_text())
    root = Path('python-results'); root.mkdir(exist_ok=True)
    statefile = root / 'state.json'
    states = json.loads(statefile.read_text()) if statefile.exists() else {}
    def save():
        temp = root / 'state.tmp'
        temp.write_text(json.dumps(states, ensure_ascii=False, indent=2))
        os.replace(temp, statefile)
    seen = set()
    for job in jobs:
        jid = job['id']
        if not re.fullmatch(r'[A-Za-z0-9_-]{1,64}', jid) or jid in seen:
            raise ValueError('id는 중복 없는 영문·숫자·밑줄·하이픈이어야 합니다')
        seen.add(jid)
        body = payload(job['prompt'])
        digest = hashlib.sha256(json.dumps(body, sort_keys=True).encode()).hexdigest()
        record = states.setdefault(jid, {'status': 'pending', 'request': digest})
        if record['request'] != digest:
            raise ValueError('같은 id의 요청이 바뀌었습니다')
        target = root / f'{jid}.png'
        if record['status'] == 'done':
            if not target.exists() or hashlib.sha256(target.read_bytes()).hexdigest() != record['sha256']:
                record.update(status='review', reason='완료 파일 없음 또는 변경'); save()
        recover(record, body, target, save)
        print(jid, record['status'], record.get('reason', ''))
        if record['status'] in ('unknown', 'stopped'):
            break

if __name__ == '__main__':
    main()

npm init -y
npm install sharp
node recover.mjs jobs.json

import fs from 'node:fs/promises';
import { createHash, randomInt } from 'node:crypto';
import { pathToFileURL } from 'node:url';
import sharp from 'sharp';

const MODEL = 'gemini-3-pro-image';
const URL = `https://generativelanguage.googleapis.com/v1beta/models/${MODEL}:generateContent`;
const MAX_ATTEMPTS = 5, BUDGET = 180, CALL_TIMEOUT = 60;
const hash = data => createHash('sha256').update(data).digest('hex');
export const payload = prompt => ({
  contents: [{ role: 'user', parts: [{ text: prompt }] }],
  generationConfig: { responseModalities: ['TEXT', 'IMAGE'],
    imageConfig: { aspectRatio: '16:9', imageSize: '1K' } }
});
export function stopReason(status, body) {
  if (![429, 503].includes(status)) return `HTTP ${status}: 수동 확인`;
  for (const d of body.error?.details ?? []) {
    if (!String(d['@type']).endsWith('QuotaFailure')) continue;
    for (const v of d.violations ?? []) {
      if (v.serviceDisabled === true) return '서비스 비활성';
      if (Object.hasOwn(v, 'quotaValue') && ['0', '0.0'].includes(String(v.quotaValue)))
        return '명시적 한도 0';
      const text = [v.quotaMetric, v.quotaId, v.description].join(' ');
      if (/per.?day|daily|\bRPD\b/i.test(text)) return '일일 한도';
    }
  }
  if (/limit\s*:\s*0(?:\D|$)|daily|per.?day|billing|payment|credits/i.test(body.error?.message ?? ''))
    return '한도 또는 결제 상태 확인';
  return null;
}
export function serverFloor(headers, body, now) {
  const value = Object.entries(headers).find(([k]) => k.toLowerCase() === 'retry-after')?.[1];
  let floor = 0;
  if (value !== undefined) {
    const seconds = /^\d+$/.test(String(value)) ? Number(value) : Date.parse(value) / 1000 - now;
    if (Number.isFinite(seconds)) floor = Math.max(floor, seconds);
  }
  for (const d of body.error?.details ?? []) {
    if (!String(d['@type']).endsWith('RetryInfo')) continue;
    const m = /^(\d+(?:\.\d+)?)s$/.exec(d.retryDelay ?? '');
    if (m) floor = Math.max(floor, Number(m[1]));
  }
  return floor;
}
export async function imageBytes(body) {
  for (const c of body.candidates ?? []) {
    for (const p of c.content?.parts ?? []) {
      const b = p.inlineData;
      if (!b || !['image/png', 'image/jpeg', 'image/webp'].includes(b.mimeType)) continue;
      if (typeof b.data !== 'string' || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(b.data))
        throw new Error('유효하지 않은 base64');
      return await sharp(Buffer.from(b.data, 'base64'), { failOn: 'warning' }).png().toBuffer();
    }
  }
  throw new Error('이미지 없음: promptFeedback와 finishReason 확인');
}
async function send(body, timeout) {
  if (!process.env.GEMINI_API_KEY) throw new Error('GEMINI_API_KEY 필요');
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeout * 1000);
  try {
    const r = await fetch(URL, { method: 'POST', redirect: 'error', signal: controller.signal,
      headers: { 'Content-Type': 'application/json', 'x-goog-api-key': process.env.GEMINI_API_KEY },
      body: JSON.stringify(body) });
    const response = await r.json(); // 본문 수신까지 timeout이 적용됩니다.
    return [r.status, Object.fromEntries(r.headers), response];
  } finally { clearTimeout(timer); }
}
export async function recover(record, body, destination, save, deps = {}) {
  const clock = deps.clock ?? (() => performance.now() / 1000);
  const wall = deps.wall ?? (() => Date.now() / 1000);
  const sleep = deps.sleep ?? (s => new Promise(resolve => setTimeout(resolve, s * 1000)));
  const transport = deps.transport ?? send;
  const started = clock(), initial = record.used ?? 0;
  const checkpoint = async (status, fields = {}) => {
    Object.assign(record, fields, { status, used: initial + clock() - started });
    await save();
  };
  if (record.status === 'inflight') await checkpoint('unknown', { reason: '이전 POST 결과 불명' });
  if (['unknown', 'stopped', 'review', 'done'].includes(record.status)) return;
  while ((record.attempts ?? 0) < MAX_ATTEMPTS) {
    let remaining = BUDGET - initial - (clock() - started);
    const delay = Math.max(0, (record.notBefore ?? 0) - wall());
    if (remaining <= delay + 0.05) {
      await checkpoint('deferred', { reason: '누적 시간 예산 부족' }); return;
    }
    if (delay) await sleep(delay);
    remaining = BUDGET - initial - (clock() - started);
    await checkpoint('inflight', { attempts: (record.attempts ?? 0) + 1 });
    remaining = BUDGET - initial - (clock() - started);
    if (remaining <= 0) {
      await checkpoint('deferred', { reason: '호출 전 시간 예산 소진' }); return;
    }
    let status, headers, response;
    try { [status, headers, response] = await transport(body, Math.min(CALL_TIMEOUT, remaining)); }
    catch { await checkpoint('unknown', { reason: 'POST 또는 응답 수신 결과 불명' }); return; }
    if (status === 200) {
      try {
        const bytes = await imageBytes(response);
        await fs.writeFile(`${destination}.tmp`, bytes);
        await fs.rename(`${destination}.tmp`, destination);
        await checkpoint('done', { file: destination, sha256: hash(bytes), responseId: response.responseId });
      } catch { await checkpoint('review', { reason: '응답 또는 이미지 저장 확인 필요',
        promptFeedback: response.promptFeedback,
        finishReasons: (response.candidates ?? []).map(c => c.finishReason) }); }
      return;
    }
    const reason = stopReason(status, response);
    if (reason) { await checkpoint('stopped', { reason, error: response.error }); return; }
    const wait = Math.max(serverFloor(headers, response, wall()),
      Math.min(16, 2 ** (record.attempts - 1))) + randomInt(0, 1000) / 1000;
    await checkpoint('pending', { notBefore: wall() + wait, reason: `HTTP ${status}` });
  }
  await checkpoint('stopped', { reason: '총 시도 횟수 소진' });
}
async function main() {
  const jobs = JSON.parse(await fs.readFile(process.argv[2], 'utf8'));
  const root = 'node-results', statefile = `${root}/state.json`;
  await fs.mkdir(root, { recursive: true });
  let states = {};
  try { states = JSON.parse(await fs.readFile(statefile, 'utf8')); }
  catch (e) { if (e.code !== 'ENOENT') throw e; }
  const save = async () => {
    await fs.writeFile(`${statefile}.tmp`, JSON.stringify(states, null, 2));
    await fs.rename(`${statefile}.tmp`, statefile);
  };
  const seen = new Set();
  for (const job of jobs) {
    const jid = job.id;
    if (!/^[A-Za-z0-9_-]{1,64}$/.test(jid) || seen.has(jid)) throw new Error('잘못된 id 또는 중복 id');
    seen.add(jid);
    const body = payload(job.prompt), digest = hash(JSON.stringify(body));
    const record = states[jid] ??= { status: 'pending', request: digest };
    if (record.request !== digest) throw new Error('같은 id의 요청이 바뀌었습니다');
    const target = `${root}/${jid}.png`;
    if (record.status === 'done') {
      try { if (hash(await fs.readFile(target)) !== record.sha256) throw new Error('변경된 파일'); }
      catch { Object.assign(record, { status: 'review', reason: '완료 파일 없음 또는 변경' }); await save(); }
    }
    await recover(record, body, target, save);
    console.log(jid, record.status, record.reason ?? '');
    if (['unknown', 'stopped'].includes(record.status)) break;
  }
}
if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) await main();