Automatic Formatting

import time
import json
import requests

BASE_URL = "https://api.fennec-asr.com/api/v1"
API_KEY = "YOUR_API_KEY_HERE"
AUDIO_URL = "https://upload.wikimedia.org/wikipedia/commons/3/3f/En-History_of_Corpus_Christi%2C_Texas.ogg"

POLL_INTERVAL_SECONDS = 5
MAX_WAIT_SECONDS = 300

formatting_options = {
    "newline_pause_threshold": 0.6,
    "double_newline_pause_threshold": 0.8
}


def submit_job():
    headers = {"Content-Type": "application/json", "X-API-Key": API_KEY}
    # The 'formatting' value MUST be a JSON-formatted string.
    payload = {
        "audio": AUDIO_URL,
        "formatting": json.dumps(formatting_options)
    }

    print("--- Submitting URL Transcription with Formatting ---")
    print(f"Audio URL: {AUDIO_URL}")
    print(f"Formatting: {payload['formatting']}")
    print("----------------------------------------------------")

    resp = requests.post(f"{BASE_URL}/transcribe/url",
                         headers=headers,
                         json=payload,
                         timeout=60)
    resp.raise_for_status()
    job_id = resp.json().get("job_id")
    if not job_id:
        raise RuntimeError("No job_id returned from submit endpoint.")
    print(f"✅ Job submitted successfully! Job ID: {job_id}\n")
    return job_id


def poll_job(job_id):
    headers = {"X-API-Key": API_KEY}
    status_url = f"{BASE_URL}/transcribe/status/{job_id}"

    start = time.monotonic()
    while time.monotonic() - start < MAX_WAIT_SECONDS:
        print("Polling for status...")
        try:
            resp = requests.get(status_url, headers=headers, timeout=30)
            if resp.status_code != 200:
                print(f"  Error polling status: HTTP {resp.status_code}")
                time.sleep(POLL_INTERVAL_SECONDS)
                continue

            data = resp.json()
            status = data.get("status")
            print(f"  Current status: '{status}'")

            if status == "completed":
                return data
            if status == "failed":
                return data
        except requests.exceptions.RequestException as e:
            print(f"  Polling error: {e}")

        time.sleep(POLL_INTERVAL_SECONDS)

    return {"status": "timeout", "transcript": None}


def main():
    try:
        job_id = submit_job()
        result = poll_job(job_id)

        status = result.get("status")
        if status == "completed":
            transcript = result.get("transcript") or ""
            print("\n🎉 Transcription complete!")
            print("-" * 60)
            print(transcript)
            print("-" * 60)
        elif status == "failed":
            print("\n❌ Transcription failed.")
            print("Error:", result.get("transcript"))
        else:
            print("\n⏰ Polling timed out.")
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")
    except Exception as e:
        print(f"Unexpected error: {e}")


if __name__ == "__main__":
    main()

#!/usr/bin/env node
"use strict";

const BASE = "https://api.fennec-asr.com/api/v1";
const KEY = process.env.ASR_API_KEY;
const AUDIO_URL =
  process.argv[2] ||
  "https://upload.wikimedia.org/wikipedia/commons/3/3f/En-History_of_Corpus_Christi%2C_Texas.ogg";

const POLL_INTERVAL_MS = 5000;
const MAX_WAIT_MS = 300000;

const formattingOptions = {
  newline_pause_threshold: 0.6,
  double_newline_pause_threshold: 0.8,
};

const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));

(async () => {
  if (!KEY) throw new Error("Set ASR_API_KEY");

  // The 'formatting' value MUST be a JSON-formatted string.
  const payload = {
    audio: AUDIO_URL,
    formatting: JSON.stringify(formattingOptions),
  };

  console.log("--- Submitting URL Transcription with Formatting ---");
  console.log(`Audio URL: ${AUDIO_URL}`);
  console.log(`Formatting: ${payload.formatting}`);
  console.log("----------------------------------------------------");

  const sub = await fetch(`${BASE}/transcribe/url`, {
    method: "POST",
    headers: {
      "X-API-Key": KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(payload),
  }).then(async (r) => {
    if (!r.ok) {
      throw new Error(`Submit failed: HTTP ${r.status}`);
    }
    return r.json();
  });

  if (!sub?.job_id) throw new Error("No job_id returned from submit endpoint.");
  console.log(`✅ Job submitted successfully! Job ID: ${sub.job_id}\n`);

  const start = Date.now();
  const statusUrl = `${BASE}/transcribe/status/${sub.job_id}`;

  for (;;) {
    console.log("Polling for status...");
    try {
      const s = await fetch(statusUrl, {
        headers: { "X-API-Key": KEY },
      }).then(async (r) => {
        if (!r.ok) {
          console.log(`  Error polling status: HTTP ${r.status}`);
          return null;
        }
        return r.json();
      });

      if (s) {
        const status = s.status;
        console.log(`  Current status: '${status}'`);

        if (status === "completed") {
          const transcript: string = s.transcript || "";
          console.log("\n🎉 Transcription complete!");
          console.log("-".repeat(60));
          console.log(transcript);
          console.log("-".repeat(60));
          return;
        }

        if (status === "failed") {
          console.error("\n❌ Transcription failed.");
          console.error("Error:", s.transcript || "");
          process.exit(1);
        }
      }
    } catch (e: any) {
      console.log(`  Polling error: ${e?.message || e}`);
    }

    if (Date.now() - start >= MAX_WAIT_MS) {
      console.error("\n⏰ Polling timed out.");
      process.exit(1);
    }

    await wait(POLL_INTERVAL_MS);
  }
})().catch((e) => {
  console.error(e.message || e);
  process.exit(1);
});