Quickstart

import json
import os
import ssl
import sys
import time
import urllib.request

import websocket

BASE_URL = "https://api.tiro.ooo"
API_KEY = os.environ["TIRO_API_KEY"]
FRAME_BYTES = 3200
FRAME_SECONDS = 0.1


def rest(method, path, body=None):
    request = urllib.request.Request(
        f"{BASE_URL}{path}",
        data=json.dumps(body).encode() if body is not None else None,
        headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
        method=method,
    )
    with urllib.request.urlopen(request) as response:
        return json.load(response)


def handle(message):
    kind = message.get("type")
    if kind in ("transcript", "translation"):
        marker = "FINAL  " if message["isFinal"] else "partial"
        print(f"{marker} {kind} ({message.get('locale')}) {message['text']}")
    elif kind == "error":
        print(f"error reason={message['reason']} retryable={message['retryable']} {message['message']}")
        if message["fatal"]:
            raise ConnectionError(message["reason"])
    elif kind == "session.ended":
        print(f"session.ended endReason={message['endReason']} audioDurationMs={message['audioDurationMs']}")


def recv_json(ws):
    raw = ws.recv()
    if not raw:
        raise ConnectionError("connection closed")
    return json.loads(raw)


def drain(ws):
    ws.settimeout(0.0)
    try:
        while True:
            handle(recv_json(ws))
    except (websocket.WebSocketTimeoutException, BlockingIOError, ssl.SSLWantReadError):
        pass
    finally:
        ws.settimeout(None)


def stream(session, pcm):
    ws = websocket.create_connection(
        session["wsUrl"],
        header=[f"Authorization: Bearer {session['streamToken']}"],
        suppress_origin=True,
    )
    started_at = time.monotonic()
    sent_seconds = 0.0
    for offset in range(0, len(pcm), FRAME_BYTES):
        ws.send_binary(pcm[offset : offset + FRAME_BYTES])
        sent_seconds += FRAME_SECONDS
        drain(ws)
        wait = started_at + sent_seconds - time.monotonic()
        if wait > 0:
            time.sleep(wait)

    ws.send(json.dumps({"type": "session.end"}))
    ws.settimeout(60)
    while True:
        message = recv_json(ws)
        handle(message)
        if message.get("type") == "session.ended":
            break
    ws.close()


def main():
    with open(sys.argv[1], "rb") as file:
        pcm = file.read()
    session = rest("POST", "/v1/external/realtime-transcriptions", {"transcriptionLocale": "ko_KR", "translationLocale": "en_US"})
    print(f"created id={session['id']}")
    try:
        stream(session, pcm)
    except (websocket.WebSocketException, ConnectionError, OSError) as error:
        print(f"websocket failed: {error}. Ending the session over REST.")
        rest("POST", f"/v1/external/realtime-transcriptions/{session['id']}/end")
        sys.exit(1)


if __name__ == "__main__":
    main()