Speech Enhancement

import asyncio

from kugelaudio import KugelAudio, load_audio

client = KugelAudio(api_key="YOUR_API_KEY")

async def main():
    result = await client.enhance.generate(load_audio("call.wav"), model="clarity-1")
    print(result.duration, "seconds")
    result.save("call-clean.wav")

asyncio.run(main())

# Without asyncio:
result = client.enhance.generate_sync(load_audio("call.wav"), model="clarity-1")
result.save("call-clean.wav")

import { KugelAudio, loadAudio } from 'kugelaudio';

const client = new KugelAudio({ apiKey: 'YOUR_API_KEY' });

const result = await client.enhance.generate(await loadAudio('call.wav'), {
  model: 'clarity-1',
});
console.log(result.duration, 'seconds');
await result.save('call-clean.wav'); // Node.js only

// In the browser, pass the file straight from an <input type="file"> and play the result
const file = input.files![0];
const cleaned = await client.enhance.generate(file, { model: 'clarity-1' });
audioElement.src = URL.createObjectURL(cleaned.toBlob());

// Not available in the Java SDK yet: POST /v1/audio/enhance
// (see the Speech enhancement API reference).

use kugelaudio::{load_audio, EnhanceOptions, KugelAudio};

let client = KugelAudio::new("YOUR_API_KEY")?;

let result = client
    .enhance()
    .generate(&load_audio("call.wav")?, &EnhanceOptions::new("clarity-1"))
    .await?;
println!("{} seconds", result.duration());
result.save("call-clean.wav")?;

#include <kugelaudio/kugelaudio.hpp>

kugelaudio::Client client{"YOUR_API_KEY"};

kugelaudio::EnhanceOptions options;
options.model = "clarity-1";
kugelaudio::EnhancedAudio result =
    client.enhance().generate(kugelaudio::load_audio("call.wav"), options);
std::cout << result.duration() << " seconds\n";
result.save("call-clean.wav");

import 'package:kugelaudio/io.dart';

final client = KugelAudio(apiKey: 'YOUR_API_KEY');

final result = await client.enhance.generate(
  await loadAudioFile('call.wav'),
  model: 'clarity-1',
);
print('${result.duration} long');
await result.saveWav('call-clean.wav'); // io.dart

// In Flutter, including the web, pass the WAV bytes you already have
// (recordingBytes: a Uint8List, for example from a file picker)
final cleaned = await client.enhance.generate(
  Audio(recordingBytes, filename: 'call.wav'),
  model: 'clarity-1',
);
final playable = cleaned.toWav(); // WAV bytes for your audio player

result = client.enhance.generate_sync(
    load_audio("meeting.wav"),
    model="clarity-1",
    speaker=load_audio("speaker.wav"),
)
result.save("one-voice.wav")

const result = await client.enhance.generate(await loadAudio('meeting.wav'), {
  model: 'clarity-1',
  speaker: await loadAudio('speaker.wav'),
});
await result.save('one-voice.wav');

// Not available in the Java SDK yet: send a speaker sample to POST /v1/audio/enhance.

let options = EnhanceOptions::new("clarity-1").speaker(load_audio("speaker.wav")?);
let result = client.enhance().generate(&load_audio("meeting.wav")?, &options).await?;
result.save("one-voice.wav")?;

kugelaudio::EnhanceOptions options;
options.model = "clarity-1";
options.speaker = kugelaudio::load_audio("speaker.wav");
kugelaudio::EnhancedAudio result =
    client.enhance().generate(kugelaudio::load_audio("meeting.wav"), options);
result.save("one-voice.wav");

final result = await client.enhance.generate(
  await loadAudioFile('meeting.wav'),
  model: 'clarity-1',
  speaker: await loadAudioFile('speaker.wav'),
);
await result.saveWav('one-voice.wav');

await client.enhance.prewarm()
result = await client.enhance.generate(load_audio("call.wav"), model="clarity-1")

await client.enhance.prewarm();
const result = await client.enhance.generate(await loadAudio('call.wav'), { model: 'clarity-1' });

// Not available in the Java SDK yet: send the warm-up request from the API reference.

client.enhance().prewarm().await;
let result = client
    .enhance()
    .generate(&load_audio("call.wav")?, &EnhanceOptions::new("clarity-1"))
    .await?;

client.enhance().prewarm();
kugelaudio::EnhancedAudio result =
    client.enhance().generate(kugelaudio::load_audio("call.wav"), options);

await client.enhance.prewarm();
final result = await client.enhance.generate(
  await loadAudioFile('call.wav'),
  model: 'clarity-1',
);

import asyncio

from kugelaudio import KugelAudio, load_audio_stream

client = KugelAudio(api_key="YOUR_API_KEY")

async def main():
    enhanced = bytearray()
    audio = load_audio_stream("call.wav")
    async for chunk in client.enhance.stream(audio, model="clarity-1"):
        enhanced += chunk  # mono PCM16 at 24 kHz, as it arrives

asyncio.run(main())

# stream_sync is the blocking form; it sends from a background thread
for chunk in client.enhance.stream_sync(load_audio_stream("call.wav"), model="clarity-1"):
    print(len(chunk), "bytes")

import { KugelAudio, loadAudio, loadAudioStream } from 'kugelaudio';

const client = new KugelAudio({ apiKey: 'YOUR_API_KEY' });

const input = await loadAudioStream('call.wav');
for await (const chunk of client.enhance.stream(input, { model: 'clarity-1' })) {
  console.log(chunk.length, 'bytes'); // mono PCM16 at 24 kHz, as Uint8Array chunks
}

// Not available in the Java SDK yet: use the /v1/audio/enhance/stream WebSocket
// (see the Speech enhancement API reference).

use futures_util::StreamExt;
use kugelaudio::{load_audio_stream, EnhanceOptions, KugelAudio};

let client = KugelAudio::new("YOUR_API_KEY")?;

let mut enhanced = Vec::new();
let input = load_audio_stream("call.wav", 0.1)?;
let mut output = client.enhance().stream(input, &EnhanceOptions::new("clarity-1"));
while let Some(chunk) = output.next().await {
    enhanced.extend_from_slice(&chunk?); // mono PCM16 at 24 kHz, as it arrives
}

kugelaudio::Client client{"YOUR_API_KEY"};

kugelaudio::EnhanceOptions options;
options.model = "clarity-1";
kugelaudio::Bytes enhanced;
client.enhance().stream(kugelaudio::load_audio_stream("call.wav"), options,
                        [&enhanced](const kugelaudio::Bytes& pcm) {
                          // mono PCM16 at 24 kHz, as it arrives
                          enhanced.insert(enhanced.end(), pcm.begin(), pcm.end());
                        });

import 'package:kugelaudio/io.dart';

final client = KugelAudio(apiKey: 'YOUR_API_KEY');

final input = await loadAudioStreamFile('call.wav'); // or AudioStream.fromWav(bytes)
await for (final chunk in client.enhance.stream(input, model: 'clarity-1')) {
  print('${chunk.length} bytes'); // mono PCM16 at 24 kHz, as Uint8List chunks
}

def pcm_chunks(path, chunk_bytes=3200):  # 0.1 s of mono PCM16 at 16 kHz
    with open(path, "rb") as f:
        while chunk := f.read(chunk_bytes):
            yield chunk

for chunk in client.enhance.stream_sync(
    pcm_chunks("call.pcm"), model="clarity-1", sample_rate=16000
):
    print(len(chunk), "bytes")

async function* capture(): AsyncGenerator<Uint8Array> {
  // yield mono PCM16 chunks at 16 kHz as your source produces them
}

for await (const chunk of client.enhance.stream(capture(), {
  model: 'clarity-1',
  sampleRate: 16000,
})) {
  play(chunk);
}

// Not available in the Java SDK yet.

use kugelaudio::PcmInput;

// capture: any futures::Stream of Vec<u8> mono PCM16 chunks at 16 kHz
let input = PcmInput::new(capture, 16_000);
let mut output = client.enhance().stream(input, &EnhanceOptions::new("clarity-1"));
while let Some(chunk) = output.next().await {
    play(&chunk?);
}

#include <fstream>

// The source is pulled on a sender thread; return std::nullopt at the end
std::ifstream file{"call.pcm", std::ios::binary};
kugelaudio::PcmSource source = [&file]() -> std::optional<kugelaudio::Bytes> {
  kugelaudio::Bytes chunk(3200);  // 0.1 s of mono PCM16 at 16 kHz
  file.read(reinterpret_cast<char*>(chunk.data()), static_cast<std::streamsize>(chunk.size()));
  chunk.resize(static_cast<std::size_t>(file.gcount()));
  if (chunk.empty()) return std::nullopt;
  return chunk;
};
client.enhance().stream(source, 16000, options,
                        [](const kugelaudio::Bytes& pcm) { play(pcm); });

// capture: any Stream<List<int>> of mono PCM16 chunks at 16 kHz
await for (final chunk in client.enhance.stream(
  capture,
  model: 'clarity-1',
  sampleRate: 16000,
)) {
  play(chunk);
}

async with client.enhance.session() as session:  # connects here
    for path in ("first.wav", "second.wav"):
        async for chunk in session.stream(load_audio_stream(path), model="clarity-1"):
            play(chunk)

const session = client.enhance.session();
await session.connect();
try {
  for (const path of ['first.wav', 'second.wav']) {
    const input = await loadAudioStream(path);
    for await (const chunk of session.stream(input, { model: 'clarity-1' })) {
      play(chunk);
    }
  }
} finally {
  await session.close();
}

// Not available in the Java SDK yet.

let options = EnhanceOptions::new("clarity-1");
let mut session = client.enhance().session();
session.connect().await?;
for path in ["first.wav", "second.wav"] {
    let mut output = session.stream(load_audio_stream(path, 0.1)?, &options);
    while let Some(chunk) = output.next().await {
        play(&chunk?);
    }
}
session.close().await;

kugelaudio::EnhanceSession session = client.enhance().session();
session.connect();
for (const char* path : {"first.wav", "second.wav"}) {
  session.stream(kugelaudio::load_audio_stream(path), options,
                 [](const kugelaudio::Bytes& pcm) { play(pcm); });
}
session.close();  // the destructor closes it too

final session = client.enhance.session();
await session.connect();
try {
  for (final path in ['first.wav', 'second.wav']) {
    final input = await loadAudioStreamFile(path);
    await for (final chunk in session.stream(input, model: 'clarity-1')) {
      play(chunk);
    }
  }
} finally {
  await session.close();
}

from kugelaudio import InsufficientCreditsError, RateLimitError

try:
    result = client.enhance.generate_sync(load_audio("call.wav"), model="clarity-1")
except RateLimitError as e:
    print("retry in", e.retry_after, "seconds")  # None for the concurrency limit
except InsufficientCreditsError as e:
    print(e.error_code, e.message)  # INSUFFICIENT_CREDITS or FREE_PERIOD_ENDED

import { InsufficientCreditsError, RateLimitError } from 'kugelaudio';

try {
  await client.enhance.generate(await loadAudio('call.wav'), { model: 'clarity-1' });
} catch (e) {
  if (e instanceof RateLimitError) {
    console.log('retry in', e.retryAfter, 'seconds'); // undefined for the concurrency limit
  } else if (e instanceof InsufficientCreditsError) {
    console.log(e.errorCode, e.message); // INSUFFICIENT_CREDITS or FREE_PERIOD_ENDED
  } else {
    throw e;
  }
}

// Not available in the Java SDK yet.

use kugelaudio::Error;

let options = EnhanceOptions::new("clarity-1");
match client.enhance().generate(&load_audio("call.wav")?, &options).await {
    Ok(result) => result.save("call-clean.wav")?,
    // None for the concurrency limit
    Err(Error::RateLimit(e)) => println!("retry in {:?} seconds", e.retry_after),
    // INSUFFICIENT_CREDITS or FREE_PERIOD_ENDED
    Err(Error::InsufficientCredits(e)) => println!("{:?} {}", e.error_code, e.message),
    Err(e) => return Err(e),
}

try {
  client.enhance().generate(kugelaudio::load_audio("call.wav"), options);
} catch (const kugelaudio::RateLimitError& e) {
  // retry_after() is empty for the concurrency limit
  std::cout << "retry in " << e.retry_after().value_or(0) << " seconds\n";
} catch (const kugelaudio::InsufficientCreditsError& e) {
  // INSUFFICIENT_CREDITS or FREE_PERIOD_ENDED
  std::cout << e.error_code().value_or("") << ' ' << e.message() << '\n';
}

try {
  await client.enhance.generate(await loadAudioFile('call.wav'), model: 'clarity-1');
} on RateLimitException catch (e) {
  print('retry in ${e.retryAfter}'); // null for the concurrency limit
} on InsufficientCreditsException catch (e) {
  print('${e.errorCode} ${e.message}'); // INSUFFICIENT_CREDITS or FREE_PERIOD_ENDED
}