Speech to Text

{
  "text": "<|speaker:0|> 你好。 <|speaker:1|> [高兴]很开心认识你。 <|speaker:0|> 我也是。",
  "duration": 6.4,
  "segments": [],
  "language_code": "zh",
  "language": "Chinese",
  "request_id": "0b6f4c1e-7d2a-4e8b-9f3c-5a1d2e3f4b6c"
}

import re

parts = re.split(r"<\|speaker:(\d+)\|>", result["text"])
lead, rest = parts[0].strip(), parts[1:]
turns = [(rest[i], rest[i + 1].strip()) for i in range(0, len(rest), 2)]
if not turns:
    turns = [("0", lead)]  # no marker: a single speaker
elif lead:
    turns[0] = (turns[0][0], f"{lead} {turns[0][1]}".strip())
for speaker, text in turns:
    if text:
        print(f"Speaker {speaker}: {text}")

Speaker 0: 你好。
Speaker 1: [高兴]很开心认识你。
Speaker 0: 我也是。

{
  "text": "<|speaker:0|> 你好。 <|speaker:1|> [高兴]很开心认识你。 <|speaker:0|> 我也是。",
  "duration": 6.4,
  "segments": [
    { "text": "你", "start": 0.32, "end": 0.56 },
    { "text": "好", "start": 0.56, "end": 0.88 },
    { "text": "很", "start": 1.84, "end": 2.04 },
    { "text": "开", "start": 2.04, "end": 2.24 },
    { "text": "心", "start": 2.24, "end": 2.48 },
    { "text": "认", "start": 2.48, "end": 2.68 },
    { "text": "识", "start": 2.68, "end": 2.88 },
    { "text": "你", "start": 2.88, "end": 3.2 },
    { "text": "我", "start": 4.56, "end": 4.8 },
    { "text": "也", "start": 4.8, "end": 5.0 },
    { "text": "是", "start": 5.0, "end": 5.36 }
  ],
  "speaker_turns": [
    { "speaker": "speaker:0", "text": "你好。", "start": 0.32, "end": 0.88 },
    {
      "speaker": "speaker:1",
      "text": "[高兴]很开心认识你。",
      "start": 1.84,
      "end": 3.2
    },
    { "speaker": "speaker:0", "text": "我也是。", "start": 4.56, "end": 5.36 }
  ],
  "language_code": "zh",
  "language": "Chinese",
  "request_id": "0b6f4c1e-7d2a-4e8b-9f3c-5a1d2e3f4b6c"
}

你好，[高兴]很开心认识你

import { readFile } from "node:fs/promises";
import { Agent, FormData, fetch } from "undici"; // npm install undici@7

// Node's built-in fetch stops waiting for a response after 5 minutes.
// This dispatcher waits up to 15 minutes.
const dispatcher = new Agent({
  headersTimeout: 900_000,
  bodyTimeout: 900_000,
});

const form = new FormData();
form.append("audio", new Blob([await readFile("meeting.mp3")]), "meeting.mp3");
form.append("ignore_timestamps", "false");

const response = await fetch("https://api.fish.audio/v1/asr", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.FISH_API_KEY}`,
    model: "transcribe-1-pro",
  },
  body: form,
  dispatcher,
});

if (!response.ok) throw new Error(await response.text());
const result = await response.json();
console.log(result.text);

import json

from fishaudio.exceptions import APIError

try:
    result = client.asr.transcribe(
        audio=audio_bytes,
        request_options=RequestOptions(
            additional_headers={"model": "transcribe-1-pro"}
        ),
    )
except APIError as e:
    try:
        error = json.loads(e.body or "{}")
    except ValueError:
        error = {}  # for example, an error without a JSON body
    print(e.status, error.get("code"), error.get("request_id"))
    raise

import asyncio
from fishaudio import AsyncFishAudio
from fishaudio.core import RequestOptions

async def main():
    client = AsyncFishAudio()  # reads FISH_API_KEY
    with open("speech.wav", "rb") as f:
        result = await client.asr.transcribe(
            audio=f.read(),
            request_options=RequestOptions(
                timeout=900,
                additional_headers={"model": "transcribe-1-pro"},
            ),
        )
    print(result.text)

asyncio.run(main())

import asyncio
from fishaudio import AsyncFishAudio
from fishaudio.core import RequestOptions

async def transcribe_all(paths):
    client = AsyncFishAudio()
    pro = RequestOptions(
        timeout=900, additional_headers={"model": "transcribe-1-pro"}
    )
    clips = [open(p, "rb").read() for p in paths]
    return await asyncio.gather(*[
        client.asr.transcribe(audio=clip, request_options=pro) for clip in clips
    ])

for result in asyncio.run(transcribe_all(["speech.wav"])):
    print(result.text)

import os
import httpx
import ormsgpack

with open("speech.wav", "rb") as f:
    audio = f.read()

payload = {"audio": audio, "language": "en", "ignore_timestamps": False}

resp = httpx.post(
    "https://api.fish.audio/v1/asr",
    content=ormsgpack.packb(payload),
    headers={
        "Authorization": f"Bearer {os.environ['FISH_API_KEY']}",
        "Content-Type": "application/msgpack",
        "model": "transcribe-1-pro",
    },
    # httpx waits 5 seconds by default; long recordings can take minutes.
    timeout=httpx.Timeout(900.0, connect=10.0),
)
resp.raise_for_status()
result = resp.json()
print(result["text"])
print(result.get("language_code"), result.get("request_id"))
for turn in result.get("speaker_turns", []):
    print(turn["speaker"], turn["start"], turn["end"], turn["text"])