FLUX API-snelstartgids: afbeeldingen genereren met CometAPI

set -e

CREATE_RESPONSE=$(curl --max-time 60 -fSs https://api.cometapi.com/flux/v1/flux-2-pro \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A clean editorial photograph of a red ceramic teapot on a pale blue table, a small yellow lemon on the right, soft window light, no text.",
    "width": 1280,
    "height": 768,
    "output_format": "png",
    "seed": 424242
  }')

TASK_ID=$(printf "%s" "$CREATE_RESPONSE" | jq -r '.id')

for ATTEMPT in $(seq 1 60); do
  RESULT=$(curl --max-time 30 -fSs "https://api.cometapi.com/flux/v1/get_result?id=$TASK_ID" \
    -H "Authorization: Bearer $COMETAPI_KEY")
  STATUS=$(printf "%s" "$RESULT" | jq -r '.status')
  echo "status: $STATUS"

  case "$STATUS" in
    Ready)
      IMAGE_URL=$(printf "%s" "$RESULT" | jq -r '.result.sample')
      curl --max-time 60 -fL "$IMAGE_URL" -o flux-result.png
      exit 0
      ;;
    Error|Failed|Failure|"Task not found"|"Request Moderated"|"Content Moderated"|failed|failure)
      echo "FLUX task failed: $STATUS" >&2
      exit 1
      ;;
  esac

  sleep 5
done

echo "FLUX task did not finish in time" >&2
exit 1

import os
import time
from pathlib import Path

import requests

headers = {"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]}
payload = {
    "prompt": (
        "A clean editorial photograph of a red ceramic teapot on a pale blue "
        "table, a small yellow lemon on the right, soft window light, no text."
    ),
    "width": 1280,
    "height": 768,
    "output_format": "png",
    "seed": 424242,
}

create_response = requests.post(
    "https://api.cometapi.com/flux/v1/flux-2-pro",
    headers={**headers, "Content-Type": "application/json"},
    json=payload,
    timeout=60,
)
create_response.raise_for_status()
task_id = create_response.json()["id"]

failure_statuses = {
    "Error",
    "Failed",
    "Failure",
    "Task not found",
    "Request Moderated",
    "Content Moderated",
    "failed",
    "failure",
}

for _ in range(60):
    result_response = requests.get(
        "https://api.cometapi.com/flux/v1/get_result",
        headers=headers,
        params={"id": task_id},
        timeout=30,
    )
    result_response.raise_for_status()
    result = result_response.json()
    status = result.get("status")
    print(status)

    if status == "Ready":
        image_response = requests.get(result["result"]["sample"], timeout=60)
        image_response.raise_for_status()
        Path("flux-result.png").write_bytes(image_response.content)
        break
    if status in failure_statuses:
        raise RuntimeError(f"FLUX task failed: {status}")

    time.sleep(5)
else:
    raise TimeoutError("FLUX task did not finish in time")

import fs from "node:fs/promises";

const authHeaders = {
  Authorization: `Bearer ${process.env.COMETAPI_KEY}`,
};

const createResponse = await fetch(
  "https://api.cometapi.com/flux/v1/flux-2-pro",
  {
    method: "POST",
    headers: { ...authHeaders, "Content-Type": "application/json" },
    signal: AbortSignal.timeout(60_000),
    body: JSON.stringify({
      prompt:
        "A clean editorial photograph of a red ceramic teapot on a pale blue table, a small yellow lemon on the right, soft window light, no text.",
      width: 1280,
      height: 768,
      output_format: "png",
      seed: 424242,
    }),
  },
);

if (!createResponse.ok) throw new Error(await createResponse.text());
const { id } = await createResponse.json();

const failureStatuses = new Set([
  "Error",
  "Failed",
  "Failure",
  "Task not found",
  "Request Moderated",
  "Content Moderated",
  "failed",
  "failure",
]);
let completed = false;

for (let attempt = 0; attempt < 60; attempt += 1) {
  const resultResponse = await fetch(
    `https://api.cometapi.com/flux/v1/get_result?id=${encodeURIComponent(id)}`,
    { headers: authHeaders, signal: AbortSignal.timeout(30_000) },
  );
  if (!resultResponse.ok) throw new Error(await resultResponse.text());

  const result = await resultResponse.json();
  console.log(result.status);

  if (result.status === "Ready") {
    const imageResponse = await fetch(result.result.sample, {
      signal: AbortSignal.timeout(60_000),
    });
    if (!imageResponse.ok) throw new Error(await imageResponse.text());
    await fs.writeFile(
      "flux-result.png",
      Buffer.from(await imageResponse.arrayBuffer()),
    );
    completed = true;
    break;
  }
  if (failureStatuses.has(result.status)) {
    throw new Error(`FLUX task failed: ${result.status}`);
  }

  await new Promise((resolve) => setTimeout(resolve, 5000));
}

if (!completed) throw new Error("FLUX task did not finish in time");