Gerar storyboard e miniaturas com gpt-image no lugar do Sora

# scripts/storyboard_consistente.py - roda na raiz video-ia; folha de personagem + um quadro por cena, custo por imagem em CSV
# pip install openai ; OPENAI_API_KEY no ambiente (nunca no código)
import base64, csv, json, os
from openai import OpenAI

client = OpenAI()
MODELO = os.environ.get("MODEL_IMAGE", "gpt-image-2.5-flare")  # id no .env, não no código
os.makedirs("storyboard", exist_ok=True)
os.makedirs("custos", exist_ok=True)

# Metade da consistência é texto: a mesma descrição física em TODOS os prompts
PERSONAGEM = ("Rafa, cozinheira brasileira de 35 anos, cabelo cacheado preso, "
              "avental de linho azul-cobalto, brincos de argola dourados")
CENARIO = ("cozinha clara em Recife, azulejos brancos com desenho português azul-cobalto, "
           "bancada de madeira clara, luz natural de janela à esquerda, paleta quente")
REGRAS = "fotografia editorial de culinária, sem texto, sem logotipos"

# Preços por 1M de tokens em 12/10/2026 (iguais no flare e no sunburst; sem cache pelos endpoints /v1/images)
US_TEXTO_IN, US_IMAGEM_IN, US_IMAGEM_OUT = 5 / 1e6, 8 / 1e6, 30 / 1e6

def custo(u):
    """Não há preço fixo por imagem: o custo sai do usage de cada resposta."""
    det = getattr(u, "input_tokens_details", None)
    img_in = (getattr(det, "image_tokens", 0) or 0) if det else 0
    return (u.input_tokens - img_in) * US_TEXTO_IN + img_in * US_IMAGEM_IN + u.output_tokens * US_IMAGEM_OUT

def salvar(resp, caminho, planilha):
    with open(caminho, "wb") as f:
        f.write(base64.b64decode(resp.data[0].b64_json))
    u = resp.usage
    planilha.writerow([caminho, u.input_tokens, u.output_tokens, f"{custo(u):.4f}"])
    print(caminho, f"US$ {custo(u):.4f}")

FOLHA = "storyboard/personagem.png"
cenas = json.load(open("storyboard/cenas.json", encoding="utf-8"))["cenas"]

with open("custos/imagens.csv", "a", newline="", encoding="utf-8") as f_csv:
    planilha = csv.writer(f_csv)

    # 1) Folha de personagem: três ângulos, fundo neutro; aprove antes do lote
    if not os.path.exists(FOLHA):  # idempotente: não paga duas vezes
        r = client.images.generate(
            model=MODELO, size="1024x1024", quality="high", output_format="png",
            prompt=f"Folha de personagem: {PERSONAGEM}, de frente, de perfil e de três quartos, "
                   f"fundo cinza neutro. {REGRAS}.")
        salvar(r, FOLHA, planilha)

    # 2) Um quadro por cena, sempre com a folha como PRIMEIRA referência
    for c in cenas:
        destino = f"storyboard/q{c['id']:02d}.png"
        if os.path.exists(destino):
            continue
        with open(FOLHA, "rb") as ref:
            r = client.images.edit(
                model=MODELO,
                image=[ref],
                prompt=("Mantenha a pessoa da imagem de referência: mesmo rosto, cabelo, avental e brincos. "
                        f"{PERSONAGEM}. {c['prompt_quadro']}. {CENARIO}. {REGRAS}."),
                size="864x1536",    # 9:16 em múltiplos de 16; o 16:9 é "1536x864"
                quality="medium",   # low para rascunho; high, xhigh ou max só na peça final
                output_format="png",
            )
        salvar(r, destino, planilha)

#!/usr/bin/env bash
# scripts/refazer_quadro.sh - corrige um quadro fora de identidade e gera a miniatura 16:9
# uso (na raiz video-ia): bash scripts/refazer_quadro.sh storyboard/q04.png "Rafa enrola o bolo de rolo na bancada, close nas mãos"
set -euo pipefail
QUADRO="$1"; INSTRUCAO="$2"

# 1) A folha de personagem vai como PRIMEIRA referência; o quadro ruim, como segunda
curl -s https://api.openai.com/v1/images/edits \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -F model="gpt-image-2.5-sunburst" \
  -F "image[]=@storyboard/personagem.png" \
  -F "image[]=@$QUADRO" \
  -F prompt="Refaça a segunda imagem com a mesma pessoa da primeira (rosto, cabelo, avental, brincos). $INSTRUCAO. Mesma luz e paleta. Sem texto, sem logotipos." \
  -F size="864x1536" \
  -F quality="high" \
  | tee /tmp/resposta.json | jq -r '.data[0].b64_json' | base64 --decode > "${QUADRO%.png}_v2.png"
jq '.usage' /tmp/resposta.json   # tokens de entrada e saída: é daqui que sai o custo

# 2) Miniatura do vídeo longo: 16:9 exato em múltiplo de 16, terço direito vazio para o título
curl -s https://api.openai.com/v1/images/edits \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -F model="gpt-image-2.5-sunburst" \
  -F "image[]=@storyboard/personagem.png" \
  -F "image[]=@marca/paleta.png" \
  -F prompt="Miniatura de YouTube 16:9 com a mesma pessoa da primeira imagem servindo cartola numa mesa clara. Aplique a paleta da segunda imagem. Deixe o terço direito vazio para o título. Não adicione texto." \
  -F size="1536x864" \
  -F quality="high" \
  | jq -r '.data[0].b64_json' | base64 --decode > storyboard/thumb.png

# scripts/gerar_com_espera.py - espera o tempo que a API pede em vez de repetir às cegas
import time
from openai import OpenAI, APIStatusError

client = OpenAI(max_retries=0)  # quem decide quando repetir é o laço abaixo

def com_espera(chamada, tentativas=3):
    for n in range(tentativas + 1):
        try:
            return chamada()
        except APIStatusError as erro:
            if erro.status_code not in (429, 503) or n == tentativas:
                raise
            cabecalho = erro.response.headers.get("retry-after")
            espera = float(cabecalho) if cabecalho else 2 ** (n + 1)  # 2, 4 e 8 s sem cabeçalho
            print(f"{erro.status_code}: esperando {espera:.0f} s (tentativa {n + 1})")
            time.sleep(espera)

# Uso no storyboard_consistente.py, com a qualidade sempre escrita:
# r = com_espera(lambda: client.images.edit(model=MODELO, image=[ref], prompt=p,
#                                          size="864x1536", quality="medium", output_format="png"))

#!/usr/bin/env bash
# scripts/migrar_gpt_image_1.sh - gpt-image-1 sai em 23/10/2026; -mini, 1.5 e chatgpt-image-latest em 01/12/2026
set -euo pipefail
PADRAO='gpt-image-1(\.5|-mini)?|chatgpt-image-latest'

# 1) Onde os ids antigos aparecem (código, .env, workflows de CI)
grep -rnE "$PADRAO" --include='*.py' --include='*.ts' --include='*.js' --include='*.json' \
  --include='*.yml' --include='*.yaml' --include='.env*' . || echo "Nenhum id antigo encontrado"

# 2) Troca pelo flare, com cópia .bak de cada arquivo alterado (revise o diff antes de apagar)
grep -rlE "$PADRAO" --include='*.py' --include='*.ts' --include='*.js' --include='.env*' . \
  | xargs -r sed -i.bak -E "s/$PADRAO/gpt-image-2.5-flare/g"

# 3) Daqui em diante, o id mora só no .env
grep -q '^MODEL_IMAGE=' .env 2>/dev/null || echo 'MODEL_IMAGE=gpt-image-2.5-flare' >> .env

# 4) Sem quality explícito, a família 2.5 responde em low: liste os arquivos que não dizem a qualidade
grep -rlE 'gpt-image-2\.5' --include='*.py' --include='*.ts' --include='*.js' . | xargs -r grep -L 'quality' || true

# 5) Teste barato: confirma acesso, verificação da organização e formato da resposta
curl -s https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer $OPENAI_API_KEY" -H "Content-Type: application/json" \
  -d '{"model":"gpt-image-2.5-flare","prompt":"Panela de barro sobre mesa de madeira, luz natural, sem texto","size":"1024x1024","quality":"low"}' \
  | jq '{erro: .error.message, usage: .usage, tem_imagem: (.data[0].b64_json != null)}'

# scripts/miniaturas.py - rode na raiz video-ia; OPENAI_API_KEY no ambiente
import base64, os, subprocess
from openai import OpenAI

client = OpenAI()
os.makedirs("storyboard/miniaturas", exist_ok=True)

with open("storyboard/personagem.png", "rb") as folha, open("marca/paleta.png", "rb") as paleta:
    r = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=[folha, paleta],                 # a folha vem sempre primeiro
        prompt=("Miniatura de YouTube 16:9 com a mesma pessoa da primeira imagem segurando "
                "um prato de cartola, expressão de surpresa, paleta da segunda imagem, "
                "terço direito vazio para o título. Sem texto, sem logotipos."),
        size="2560x1440",                     # 16:9 em múltiplos de 16, fora da faixa experimental
        quality="high",
        n=3,                                  # três variações no mesmo pedido
        output_format="png",
    )

for i, img in enumerate(r.data, 1):
    png = f"storyboard/miniaturas/v{i}.png"
    with open(png, "wb") as f:
        f.write(base64.b64decode(img.b64_json))
    jpg = png.replace(".png", ".jpg")
    # JPG de qualidade alta; o YouTube aceita JPG ou PNG, não WebP
    subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", png, "-q:v", "3", jpg], check=True)
    kb = os.path.getsize(jpg) // 1024
    print(jpg, kb, "KB", "(acima de 2 MB não sobe pelo celular)" if kb > 2048 else "")

print("usage:", r.usage)   # o custo sai daqui, como na aula

# Nos quadros de rascunho, troque o output_format="png" por:
#     output_format="webp", output_compression=80,
# e grave com a extensão .webp. O PNG fica só para a peça final.
# Para o slideshow da aula, o FFmpeg lê WebP do mesmo jeito (file 'q01.webp').