Voice Design

import os
import time

import requests

BASE_URL = "https://api.gradium.ai/api"
HEADERS = {"x-api-key": os.environ["GRADIUM_API_KEY"]}

DESCRIPTION = (
    "A British female voice, 20 to 30, glossy and confident, with high pitch, "
    "fast pacing, high energy and bright sparkling resonance. Ideal for a "
    "friendly receptionist or assistant."
)
AUDITION_LINE = "Hi there, thanks so much for calling Northgate! How can I help you today?"


def check(resp):
    if not resp.ok:
        raise RuntimeError(f"HTTP {resp.status_code}: {resp.text}")
    return resp


def generate(prompt, language="en", n_samples=3, json_config=None):
    body = {"prompt": prompt, "language": language, "n_samples": n_samples}
    if json_config:
        body["json_config"] = json_config
    resp = check(requests.post(f"{BASE_URL}/voice-generator/generate", headers=HEADERS, json=body))
    return [c["embedding_id"] for c in resp.json()["embeddings"]]


def wait_until_ready(candidate_ids, timeout_s=120.0):
    deadline = time.monotonic() + timeout_s
    pending = set(candidate_ids)
    while pending:
        for candidate_id in sorted(pending):
            resp = check(requests.get(
                f"{BASE_URL}/voice-generator/embeddings",
                headers=HEADERS,
                params={"embedding_id": candidate_id},
            ))
            embeddings = resp.json()["embeddings"]
            if not embeddings:
                raise RuntimeError(f"candidate {candidate_id} not found")
            if embeddings[0]["ready"]:
                pending.discard(candidate_id)
        if pending:
            if time.monotonic() > deadline:
                raise TimeoutError(f"still not ready: {sorted(pending)}")
            time.sleep(2.0)


def synthesise(voice_id, text, path):
    resp = check(requests.post(
        f"{BASE_URL}/post/speech/tts",
        headers=HEADERS,
        json={"text": text, "voice_id": voice_id, "output_format": "wav", "only_audio": True},
    ))
    with open(path, "wb") as f:
        f.write(resp.content)


def convert(candidate_id, name, description=None):
    resp = check(requests.post(
        f"{BASE_URL}/voices/from-embedding",
        headers=HEADERS,
        json={"voxium_embedding_id": candidate_id, "name": name, "description": description},
    ))
    return resp.json()["uid"]


def delete_candidate(candidate_id):
    requests.delete(f"{BASE_URL}/voice-generator/embeddings/{candidate_id}", headers=HEADERS)


if __name__ == "__main__":
    print("[1/5] generating candidates")
    candidate_ids = generate(DESCRIPTION, language="en", n_samples=3)

    print("[2/5] waiting until ready")
    wait_until_ready(candidate_ids)

    print("[3/5] auditioning")
    for i, candidate_id in enumerate(candidate_ids):
        synthesise(candidate_id, AUDITION_LINE, f"candidate-{i}.wav")
        print(f"      candidate-{i}.wav  {candidate_id}")

    # Listen to the files, then pick one. This example keeps the first.
    chosen = candidate_ids[0]

    print("[4/5] converting the chosen candidate into a voice")
    voice_id = convert(chosen, "Receptionist EN", "Front desk and appointment booking")
    print(f"      voice_id={voice_id}")

    print("[5/5] synthesising with the new voice")
    synthesise(
        voice_id,
        "Good morning, and welcome to Northgate! Do you have an appointment with us "
        "today, or shall I get you booked in?",
        "welcome.wav",
    )

    for candidate_id in candidate_ids:
        if candidate_id != chosen:
            delete_candidate(candidate_id)
    print("done")

import { writeFile } from "node:fs/promises";

const BASE_URL = "https://api.gradium.ai/api";
const HEADERS = {
  "x-api-key": process.env.GRADIUM_API_KEY,
  "Content-Type": "application/json",
};

const DESCRIPTION =
  "A British female voice, 20 to 30, glossy and confident, with high pitch, " +
  "fast pacing, high energy and bright sparkling resonance. Ideal for a " +
  "friendly receptionist or assistant.";
const AUDITION_LINE =
  "Hi there, thanks so much for calling Northgate! How can I help you today?";

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function check(resp) {
  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${await resp.text()}`);
  return resp;
}

async function generate(prompt, { language = "en", nSamples = 3, jsonConfig } = {}) {
  const body = { prompt, language, n_samples: nSamples };
  if (jsonConfig) body.json_config = jsonConfig;
  const resp = await check(
    await fetch(`${BASE_URL}/voice-generator/generate`, {
      method: "POST",
      headers: HEADERS,
      body: JSON.stringify(body),
    }),
  );
  return (await resp.json()).embeddings.map((c) => c.embedding_id);
}

async function waitUntilReady(ids, timeoutMs = 120_000) {
  const deadline = Date.now() + timeoutMs;
  const pending = new Set(ids);
  while (pending.size > 0) {
    for (const id of [...pending]) {
      const resp = await check(
        await fetch(`${BASE_URL}/voice-generator/embeddings?embedding_id=${id}`, {
          headers: HEADERS,
        }),
      );
      const { embeddings } = await resp.json();
      if (embeddings.length === 0) throw new Error(`candidate ${id} not found`);
      if (embeddings[0].ready) pending.delete(id);
    }
    if (pending.size > 0) {
      if (Date.now() > deadline) throw new Error(`still not ready: ${[...pending]}`);
      await sleep(2000);
    }
  }
}

async function synthesise(voiceId, text, path) {
  const resp = await check(
    await fetch(`${BASE_URL}/post/speech/tts`, {
      method: "POST",
      headers: HEADERS,
      body: JSON.stringify({ text, voice_id: voiceId, output_format: "wav", only_audio: true }),
    }),
  );
  await writeFile(path, Buffer.from(await resp.arrayBuffer()));
}

async function convert(candidateId, name, description) {
  const resp = await check(
    await fetch(`${BASE_URL}/voices/from-embedding`, {
      method: "POST",
      headers: HEADERS,
      body: JSON.stringify({ voxium_embedding_id: candidateId, name, description }),
    }),
  );
  return (await resp.json()).uid;
}

async function deleteCandidate(candidateId) {
  await fetch(`${BASE_URL}/voice-generator/embeddings/${candidateId}`, {
    method: "DELETE",
    headers: HEADERS,
  });
}

console.log("[1/5] generating candidates");
const candidateIds = await generate(DESCRIPTION, { language: "en", nSamples: 3 });

console.log("[2/5] waiting until ready");
await waitUntilReady(candidateIds);

console.log("[3/5] auditioning");
for (const [i, candidateId] of candidateIds.entries()) {
  await synthesise(candidateId, AUDITION_LINE, `candidate-${i}.wav`);
  console.log(`      candidate-${i}.wav  ${candidateId}`);
}

// Listen to the files, then pick one. This example keeps the first.
const chosen = candidateIds[0];

console.log("[4/5] converting the chosen candidate into a voice");
const voiceId = await convert(chosen, "Receptionist EN", "Front desk and appointment booking");
console.log(`      voice_id=${voiceId}`);

console.log("[5/5] synthesising with the new voice");
await synthesise(
  voiceId,
  "Good morning, and welcome to Northgate! Do you have an appointment with us " +
    "today, or shall I get you booked in?",
  "welcome.wav",
);

for (const candidateId of candidateIds) {
  if (candidateId !== chosen) await deleteCandidate(candidateId);
}
console.log("done");