import { FastTranscriptionClient, Language, ASRModel }
  from '@humain-voice/sdk';
import { readFile } from 'node:fs/promises';

const client = new FastTranscriptionClient({
  api_url: process.env.API_URL,
  api_key: process.env.API_KEY,
});
await client.connect();

const audio = await readFile('meeting.wav');
const result = await client.transcribe(
  audio, Language.ArEn, ASRModel.BayanArEn,
);

console.log(result.transcription);
console.log(result.words[0]); // { word, start_time, end_time }

import os
from humain_voice import stt

with stt.FastTranscriptionClient(
    api_url=os.getenv("API_URL"),
    api_key=os.getenv("API_KEY"),
) as client:
    with open("meeting.wav", "rb") as f:
        result = client.transcribe_sync(
            f, stt.Language.ArEn, stt.ASRModel.BayanArEn
        )

print(result.transcription)
print(result.words[0])  # word, start_time, end_time

import { RealtimeClient, Language } from '@humain-voice/sdk';

const client = new RealtimeClient({
  api_url: process.env.API_URL,
  api_key: process.env.API_KEY,
});

const stream = await client.startStream(Language.ArEn, {
  onResponse: (r) => {
    if (r.is_final) console.log(r.transcription);
  },
});

// 16 kHz mono PCM16, ~100 ms per chunk
for await (const chunk of microphone()) {
  await stream.send(chunk);
}
await stream.close(1);

import asyncio, os
from humain_voice import stt

async def main():
    client = stt.RealtimeClient(
        api_url=os.getenv("API_URL"),
        api_key=os.getenv("API_KEY"),
    )
    stream = await client.start_stream(
        language=stt.Language.ArEn,
        on_response=lambda r: r.is_final and print(r.transcription),
    )

    # 16 kHz mono PCM16, ~100 ms per chunk
    async for chunk in microphone():
        await stream.send(chunk)
    await stream.close(timeout_seconds=1)

asyncio.run(main())

import { TTSClient, TtsModel } from '@humain-voice/sdk';
import { writeFile } from 'node:fs/promises';

const client = new TTSClient({
  api_url: process.env.API_URL,
  api_key: process.env.API_KEY,
});

const [voice] = await client.listVoices();

const pcm = await client.synthesize('أهلاً! كيف أقدر أساعدك اليوم؟', {
  voice_id: voice.id,
  model: TtsModel.Nebula,
});
await writeFile('greeting.pcm', pcm);

import os
from humain_voice import tts

client = tts.TTSClient(
    api_url=os.getenv("API_URL"),
    api_key=os.getenv("API_KEY"),
)

voice = client.list_voices_sync()[0]

pcm = client.synthesize_sync(
    "أهلاً! كيف أقدر أساعدك اليوم؟",
    voice_id=voice.id,
    model=tts.TtsModel.Nebula,
)
open("greeting.pcm", "wb").write(pcm)

import { TTSClient, TtsModel } from '@humain-voice/sdk';

const client = new TTSClient({
  api_url: process.env.API_URL,
  api_key: process.env.API_KEY,
});

const [voice] = await client.listVoices();

for await (const response of client.synthesizeStream(
  'أهلاً! يبدأ التشغيل قبل اكتمال الجملة.',
  {
    voice_id: voice.id,
    model: TtsModel.Nebula,
  },
)) {
  await play(response.audio);
}

import asyncio, os
from humain_voice import tts

async def main():
    client = tts.TTSClient(
        api_url=os.getenv("API_URL"),
        api_key=os.getenv("API_KEY"),
    )
    voices = await client.list_voices()

    async for response in client.synthesize_stream(
        text="أهلاً! يبدأ التشغيل قبل اكتمال الجملة.",
        voice_id=voices[0]["id"],
        model=tts.TtsModel.Nebula,
    ):
        await play(response.audio)

asyncio.run(main())

import { TTSClient, TtsModel } from '@humain-voice/sdk';
import { readFile, writeFile } from 'node:fs/promises';

const client = new TTSClient({
  api_url: process.env.API_URL,
  api_key: process.env.API_KEY,
});

const reference = await readFile('reference.pcm', 'base64');
const pcm = await client.synthesize('مرحباً من صوتي الجديد!', {
  voice_references: [{
    text: 'هذه هي الجملة الموجودة في التسجيل المرجعي.',
    audio: reference,
  }],
  model: TtsModel.Nebula,
});

await writeFile('cloned-voice.pcm', pcm);

import base64, os
from humain_voice import tts

client = tts.TTSClient(
    api_url=os.getenv("API_URL"),
    api_key=os.getenv("API_KEY"),
)

with open("reference.pcm", "rb") as f:
    reference = base64.b64encode(f.read()).decode("ascii")

pcm = client.synthesize_sync(
    "مرحباً من صوتي الجديد!",
    voice_references=[{
        "text": "هذه هي الجملة الموجودة في التسجيل المرجعي.",
        "audio": reference,
    }],
    model=tts.TtsModel.Nebula,
)

open("cloned-voice.pcm", "wb").write(pcm)

import {
  RealtimeDiarizationClient,
  DIARIZATION_RECOMMENDED_CHUNK_BYTES as CHUNK,
} from '@humain-voice/sdk';

const client = new RealtimeDiarizationClient({
  api_url: process.env.API_URL,
  api_key: process.env.API_KEY,
});

const stream = await client.startStream({
  onUpdate: (u) => {
    for (const s of u.newlyFinalized) {
      console.log(s.speaker, s.start_time, s.end_time);
    }
  },
});

// 480 ms of 16 kHz PCM16 per send
for await (const chunk of microphone(CHUNK)) {
  await stream.send(chunk);
}
const timeline = await stream.close(5);

import asyncio, os
from humain_voice import stt

def on_update(u):
    for s in u.newly_finalized:
        print(s.speaker, s.start_time, s.end_time)

async def main():
    client = stt.RealtimeDiarizationClient(
        api_url=os.getenv("API_URL"),
        api_key=os.getenv("API_KEY"),
    )
    stream = await client.start_stream(on_update=on_update)

    # 480 ms of 16 kHz PCM16 per send
    chunk_bytes = stt.DIARIZATION_RECOMMENDED_CHUNK_BYTES
    async for chunk in microphone(chunk_bytes):
        await stream.send(chunk)
    timeline = await stream.close(timeout_seconds=5)

asyncio.run(main())