Upload a video file

#!/usr/bin/env bash
# This script needs curl and jq.
set -o pipefail
FILE="keynote.mp4"
API="https://api.gpt-video.com/v1"
AUTH="Authorization: Bearer $GPT_VIDEO_API_KEY"

# 1. Start the upload with the exact size of the file, or read it again to resume.
if [ -n "$UPLOAD_ID" ]; then
  UPLOAD=$(curl -sS --fail-with-body "$API/uploads/$UPLOAD_ID" -H "$AUTH") || { echo "$UPLOAD"; exit 1; }
else
  # Create the key once. Send this same key again if you retry this request.
  IDEMPOTENCY_KEY=$(uuidgen)
  UPLOAD=$(curl -sS --fail-with-body -X POST "$API/uploads" \
    -H "$AUTH" \
    -H "Idempotency-Key: $IDEMPOTENCY_KEY" \
    -H "Content-Type: application/json" \
    -d "$(jq -n --arg name "$FILE" --argjson size "$(wc -c < "$FILE")" '{filename: $name, sizeBytes: $size}')") || { echo "$UPLOAD"; exit 1; }
fi
UPLOAD_ID=$(printf '%s' "$UPLOAD" | jq -r '.upload.id')
PART_SIZE=$(printf '%s' "$UPLOAD" | jq -r '.upload.partSizeBytes')
echo "Upload $UPLOAD_ID. To resume it later, set UPLOAD_ID to this id."

# 2. Send the parts that have not arrived. A part that fails is sent again in the next round.
for ROUND in 1 2 3; do
  MISSING=$(printf '%s' "$UPLOAD" | jq -r '[range(1; .upload.partCount + 1)] - .upload.receivedParts | .[]')
  [ -z "$MISSING" ] && break
  for PART in $MISSING; do
    dd if="$FILE" bs="$PART_SIZE" skip=$((PART - 1)) count=1 2>/dev/null |
      curl -sS --fail-with-body -X PUT "$API/uploads/$UPLOAD_ID/parts/$PART" \
        -H "$AUTH" \
        -H "Content-Type: application/octet-stream" \
        --data-binary @- > /dev/null ||
      echo "Part $PART did not arrive. It is sent again in the next round."
  done
  # Read the upload again. receivedParts lists the parts that arrived.
  UPLOAD=$(curl -sS --fail-with-body "$API/uploads/$UPLOAD_ID" -H "$AUTH") || { echo "$UPLOAD"; exit 1; }
done
MISSING=$(printf '%s' "$UPLOAD" | jq -r '[range(1; .upload.partCount + 1)] - .upload.receivedParts | .[]')
if [ -n "$MISSING" ]; then
  echo "Parts still missing after 3 rounds. Run the script again with UPLOAD_ID=$UPLOAD_ID"
  exit 1
fi

# 3. Complete the upload. The answer holds the asset that create_project takes.
# Create the key once. Send this same key again if you retry this request.
IDEMPOTENCY_KEY=$(uuidgen)
ASSET=$(curl -sS --fail-with-body -X POST "$API/uploads/$UPLOAD_ID/complete" \
  -H "$AUTH" \
  -H "Idempotency-Key: $IDEMPOTENCY_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Keynote"}') || { echo "$ASSET"; exit 1; }
ASSET_ID=$(printf '%s' "$ASSET" | jq -r '.asset.id')
echo "Asset $ASSET_ID is ready."

import { open, stat } from "node:fs/promises";

const file = "keynote.mp4";
const api = "https://api.gpt-video.com/v1";
const auth = `Bearer ${process.env.GPT_VIDEO_API_KEY}`;

// 1. Start the upload with the exact size of the file, or read it again to resume.
let res;
if (process.env.UPLOAD_ID) {
  res = await fetch(`${api}/uploads/${process.env.UPLOAD_ID}`, { headers: { Authorization: auth } });
} else {
  // Create the key once. Send this same key again if you retry this request.
  const idempotencyKey = crypto.randomUUID();
  res = await fetch(`${api}/uploads`, {
    method: "POST",
    headers: { Authorization: auth, "Idempotency-Key": idempotencyKey, "Content-Type": "application/json" },
    body: JSON.stringify({ filename: file, sizeBytes: (await stat(file)).size }),
  });
}
if (!res.ok) throw new Error(await res.text());
let upload = (await res.json()).upload;
console.log(`Upload ${upload.id}. To resume it later, set UPLOAD_ID to this id.`);

// 2. Send the parts that have not arrived. A part that fails is sent again in the next round.
const handle = await open(file);
for (let round = 1; upload.receivedParts.length < upload.partCount; round++) {
  if (round > 3) throw new Error(`Parts still missing after 3 rounds. Run the script again with UPLOAD_ID=${upload.id}`);
  for (let part = 1; part <= upload.partCount; part++) {
    if (upload.receivedParts.includes(part)) continue;
    const start = (part - 1) * upload.partSizeBytes;
    const bytes = new Uint8Array(Math.min(upload.partSizeBytes, upload.sizeBytes - start));
    await handle.read(bytes, 0, bytes.length, start);
    const sent = await fetch(`${api}/uploads/${upload.id}/parts/${part}`, {
      method: "PUT",
      headers: { Authorization: auth, "Content-Type": "application/octet-stream" },
      body: bytes,
    }).catch(() => null);
    if (!sent?.ok) console.log(`Part ${part} did not arrive. It is sent again in the next round.`);
  }
  // Read the upload again. receivedParts lists the parts that arrived.
  res = await fetch(`${api}/uploads/${upload.id}`, { headers: { Authorization: auth } });
  if (!res.ok) throw new Error(await res.text());
  upload = (await res.json()).upload;
}
await handle.close();

// 3. Complete the upload. The answer holds the asset that create_project takes.
// Create the key once. Send this same key again if you retry this request.
const completeKey = crypto.randomUUID();
res = await fetch(`${api}/uploads/${upload.id}/complete`, {
  method: "POST",
  headers: { Authorization: auth, "Idempotency-Key": completeKey, "Content-Type": "application/json" },
  body: JSON.stringify({ title: "Keynote" }),
});
if (!res.ok) throw new Error(await res.text());
const assetId = (await res.json()).asset.id;
console.log(`Asset ${assetId} is ready.`);

import os
import uuid

import requests

FILE = "keynote.mp4"
API = "https://api.gpt-video.com/v1"
AUTH = {"Authorization": f"Bearer {os.environ['GPT_VIDEO_API_KEY']}"}


def check(r):
    if not r.ok:
        raise RuntimeError(r.text)
    return r.json()


# 1. Start the upload with the exact size of the file, or read it again to resume.
if os.environ.get("UPLOAD_ID"):
    upload = check(requests.get(f"{API}/uploads/{os.environ['UPLOAD_ID']}", headers=AUTH))["upload"]
else:
    # Create the key once. Send this same key again if you retry this request.
    idempotency_key = str(uuid.uuid4())
    upload = check(requests.post(
        f"{API}/uploads",
        headers={**AUTH, "Idempotency-Key": idempotency_key},
        json={"filename": FILE, "sizeBytes": os.path.getsize(FILE)},
    ))["upload"]
print(f"Upload {upload['id']}. To resume it later, set UPLOAD_ID to this id.")

# 2. Send the parts that have not arrived. A part that fails is sent again in the next round.
with open(FILE, "rb") as f:
    rounds = 0
    while len(upload["receivedParts"]) < upload["partCount"]:
        rounds += 1
        if rounds > 3:
            raise RuntimeError(f"Parts still missing after 3 rounds. Run the script again with UPLOAD_ID={upload['id']}")
        for part in range(1, upload["partCount"] + 1):
            if part in upload["receivedParts"]:
                continue
            f.seek((part - 1) * upload["partSizeBytes"])
            try:
                sent = requests.put(
                    f"{API}/uploads/{upload['id']}/parts/{part}",
                    headers={**AUTH, "Content-Type": "application/octet-stream"},
                    data=f.read(upload["partSizeBytes"]),
                ).ok
            except requests.RequestException:
                sent = False
            if not sent:
                print(f"Part {part} did not arrive. It is sent again in the next round.")
        # Read the upload again. receivedParts lists the parts that arrived.
        upload = check(requests.get(f"{API}/uploads/{upload['id']}", headers=AUTH))["upload"]

# 3. Complete the upload. The answer holds the asset that create_project takes.
# Create the key once. Send this same key again if you retry this request.
idempotency_key = str(uuid.uuid4())
asset = check(requests.post(
    f"{API}/uploads/{upload['id']}/complete",
    headers={**AUTH, "Idempotency-Key": idempotency_key},
    json={"title": "Keynote"},
))["asset"]
print(f"Asset {asset['id']} is ready.")