Async Queue

import json
import requests
import threading
import time

API_KEY = "YOUR_API_KEY"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def listen(results):
    with requests.get(
        "https://hub.oxen.ai/api/events",
        headers=HEADERS,
        stream=True,
    ) as resp:
        event_name = None
        for line in resp.iter_lines(decode_unicode=True):
            if line is None or line == "":
                event_name = None
                continue
            if line.startswith(":"):
                continue  # keep-alive comment
            if line.startswith("event:"):
                event_name = line[6:].strip()
            elif line.startswith("data:") and event_name == "media_generation_completed":
                payload = json.loads(line[5:].strip())
                results[payload["generation_id"]] = payload

# Start listening BEFORE enqueuing
results = {}
threading.Thread(target=listen, args=(results,), daemon=True).start()
print("SSE listener connected, waiting for events...")

# Enqueue
prompt = "A red cube"
model = "black-forest-labs-flux-2-klein-4b"
print(f"\nEnqueuing {model}")
print(f"  prompt: \"{prompt}\"")
resp = requests.post(
    "https://hub.oxen.ai/api/ai/queue",
    headers={**HEADERS, "Content-Type": "application/json"},
    json={
        "model": model,
        "prompt": prompt,
    },
)
gen_id = resp.json()["generations"][0]["generation_id"]
print(f"  generation_id: {gen_id}")

# Wait for completion event
start = time.time()
while gen_id not in results:
    elapsed = time.time() - start
    print(f"  Waiting for SSE completion event... ({elapsed:.1f}s)")
    time.sleep(2)

elapsed = time.time() - start
event = results[gen_id]
if event["status"] == "succeeded":
    print(f"\nGeneration succeeded in {elapsed:.1f}s")
    print(f"  URL: {event['url']}")
elif event["status"] == "failed":
    print(f"\nGeneration failed after {elapsed:.1f}s")
    print(f"  Error: {event['error']}")
else:
    print(f"\nGeneration cancelled after {elapsed:.1f}s")

curl -N -H "Authorization: Bearer $OXEN_API_KEY" \
  https://hub.oxen.ai/api/events

import requests

API_KEY = "YOUR_API_KEY"
NAMESPACE = "YOUR_USERNAME"
REPO = "playground"  # the target_repo your generations write to
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}
SESSIONS_URL = f"https://hub.oxen.ai/api/repos/{NAMESPACE}/{REPO}/workbench/sessions"

# 1. Start a session for this task
session = requests.post(
    SESSIONS_URL,
    headers=HEADERS,
    json={"payload": {"name": "Product shots"}},
).json()["workbench_session"]
session_id = session["id"]

# 2. Tag every generation in the task with the session ID
for prompt in ["A red sneaker on white", "A blue sneaker on white"]:
    requests.post(
        "https://hub.oxen.ai/api/ai/queue",
        headers=HEADERS,
        json={
            "model": "black-forest-labs-flux-2-klein-4b",
            "prompt": prompt,
            "target_repo": REPO,
            "workbench_session_id": session_id,
        },
    ).raise_for_status()

# 3. Read back everything in the session, including generations still in the queue
history = requests.get(
    f"https://hub.oxen.ai/api/repos/{NAMESPACE}/{REPO}/workbench/history",
    headers=HEADERS,
    params={"filter[workbench_session_id]": session_id},
).json()
for row in history["data_frame"]["view"]["data"]:
    print(row["uuid"], row["status"], row["prompt"])

# 4. Find a session again later
for s in requests.get(SESSIONS_URL, headers=HEADERS).json()["workbench_sessions"]:
    print(s["id"], s["default"], s["payload"].get("name"))

# 5. Delete the session when you're done. The generations are kept.
requests.delete(f"{SESSIONS_URL}/{session_id}", headers=HEADERS)

# Create a session
curl -X POST "https://hub.oxen.ai/api/repos/$NAMESPACE/playground/workbench/sessions" \
  -H "Authorization: Bearer $OXEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"payload": {"name": "Product shots"}}'

# Enqueue into it
curl -X POST https://hub.oxen.ai/api/ai/queue \
  -H "Authorization: Bearer $OXEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "black-forest-labs-flux-2-klein-4b",
    "prompt": "A red sneaker on white",
    "workbench_session_id": "'"$SESSION_ID"'"
  }'

# List the session's generations
curl -G -H "Authorization: Bearer $OXEN_API_KEY" \
  "https://hub.oxen.ai/api/repos/$NAMESPACE/playground/workbench/history" \
  --data-urlencode "filter[workbench_session_id]=$SESSION_ID"

# Delete the session
curl -X DELETE -H "Authorization: Bearer $OXEN_API_KEY" \
  "https://hub.oxen.ai/api/repos/$NAMESPACE/playground/workbench/sessions/$SESSION_ID"

import requests
import time

API_KEY = "YOUR_API_KEY"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

# Enqueue 4 images
model = "black-forest-labs-flux-2-klein-4b"
prompt = "Abstract geometric pattern in blue and gold"
print(f"Enqueuing 4 generations of {model}")
print(f"  prompt: \"{prompt}\"")
response = requests.post(
    "https://hub.oxen.ai/api/ai/queue",
    headers=HEADERS,
    json={
        "model": model,
        "prompt": prompt,
        "num_generations": 4,
    },
)
gen_ids = [g["generation_id"] for g in response.json()["generations"]]
for gid in gen_ids:
    print(f"  generation_id: {gid}")

# Poll individual generations until all reach a terminal status
terminal = {"succeeded", "failed", "cancelled"}
start = time.time()
while True:
    statuses = {}
    for gid in gen_ids:
        resp = requests.get(
            f"https://hub.oxen.ai/api/ai/queue/{gid}",
            headers=HEADERS,
        ).json()
        statuses[gid] = resp["status"]
    done = sum(1 for s in statuses.values() if s in terminal)
    elapsed = time.time() - start
    print(f"  [{elapsed:5.1f}s] {done}/{len(gen_ids)} complete")
    if done == len(gen_ids):
        break
    time.sleep(5)

elapsed = time.time() - start
print(f"\nAll {len(gen_ids)} images generated in {elapsed:.1f}s!")
for gid, s in statuses.items():
    print(f"  {gid}: {s}")

# Enqueue 4 images
curl -s -X POST https://hub.oxen.ai/api/ai/queue \
  -H "Authorization: Bearer $OXEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "black-forest-labs-flux-2-klein-4b",
    "prompt": "Abstract geometric pattern in blue and gold",
    "num_generations": 4
  }'

# Poll until all active generations are done
while true; do
  STATUS=$(curl -s -H "Authorization: Bearer $OXEN_API_KEY" \
    "https://hub.oxen.ai/api/ai/queue?model=black-forest-labs-flux-2-klein-4b")
  COUNT=$(echo "$STATUS" | python3 -c "import json,sys; print(json.load(sys.stdin)['count'])")
  echo "Active: $COUNT"
  [ "$COUNT" -eq 0 ] && break
  sleep 5
done

echo "All images generated!"

import requests

response = requests.post(
    "https://hub.oxen.ai/api/ai/queue",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "model": "kling-video-o3-pro-reference-to-video",
        "multi_prompt": [
            {"prompt": "Aerial view of waves crashing on a rocky shore", "duration": 5},
            {"prompt": "Camera pulls back to reveal the full coastline", "duration": 5},
        ],
        "aspect_ratio": "16:9",
    },
)

print(response.json())

curl -X POST https://hub.oxen.ai/api/ai/queue \
  -H "Authorization: Bearer $OXEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling-video-o3-pro-reference-to-video",
    "multi_prompt": [
      {"prompt": "Aerial view of waves crashing on a rocky shore", "duration": 5},
      {"prompt": "Camera pulls back to reveal the full coastline", "duration": 5}
    ],
    "aspect_ratio": "16:9"
  }'

import requests
import time

API_KEY = "YOUR_API_KEY"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

# After enqueuing, grab a generation ID
generation_id = "YOUR_GENERATION_ID"
print(f"Polling generation {generation_id}")

terminal = {"succeeded", "failed", "cancelled"}
start = time.time()
poll_count = 0
while True:
    poll_count += 1
    data = requests.get(
        f"https://hub.oxen.ai/api/ai/queue/{generation_id}",
        headers=HEADERS,
    ).json()
    elapsed = time.time() - start
    status = data["status"]
    if status in terminal:
        print(f"  [{elapsed:5.1f}s] Generation {status}")
        if status == "succeeded":
            print(f"  result_url: {data['result_url']}")
        elif status == "failed":
            print(f"  error: {data['error_message']}")
        break
    print(f"  [{elapsed:5.1f}s] Poll #{poll_count} — {status} ({data['model_name']}, {data['media_type']})")
    time.sleep(10)

# Check a specific generation
curl -H "Authorization: Bearer $OXEN_API_KEY" \
  "https://hub.oxen.ai/api/ai/queue/$GENERATION_ID"

# Cancel a generation
curl -X DELETE -H "Authorization: Bearer $OXEN_API_KEY" \
  "https://hub.oxen.ai/api/ai/queue/$GENERATION_ID"