Python

import os
from pathlib import Path
import sys
import wave

import aic_sdk as aic
import numpy as np


def main():
    license_key = os.environ.get("AIC_SDK_LICENSE")
    if not license_key or license_key == "YOUR_SDK_KEY":
        raise ValueError("Set AIC_SDK_LICENSE to your SDK key, then retry.")

    with wave.open("input.wav", "rb") as source:
        if (source.getnchannels(), source.getframerate(), source.getsampwidth()) != (1, 16000, 2):
            raise ValueError("Export input.wav as mono, 16 kHz, 16-bit PCM WAV, then retry.")
        frames = source.getnframes()
        raw = source.readframes(frames)
        if len(raw) != frames * 2:
            raise ValueError("input.wav is truncated. Export the complete recording, then retry.")
    audio = np.frombuffer(raw, dtype="<i2").astype(np.float32) / 32768.0
    if audio.size == 0:
        raise ValueError("input.wav is empty. Record speech, then retry.")

    model_path = aic.Model.download("quail-vf-2.2-l-16khz", Path("models"))
    model = aic.Model.from_file(model_path)
    config = aic.ProcessorConfig.optimal(model, sample_rate=16000)
    processor = aic.Processor(model, license_key)
    try:
        processor.initialize(config)
        delay = processor.get_context().get_audio_delay()
        # Pad the last block and flush the delayed tail with silence.
        padded_size = ((audio.size + delay + config.block_size - 1) // config.block_size) * config.block_size
        padded = np.zeros(padded_size, dtype=np.float32)
        padded[:audio.size] = audio
        output = np.empty_like(padded)
        for start in range(0, padded_size, config.block_size):
            end = start + config.block_size
            # Python returns a new array; the input block is unchanged.
            output[start:end] = processor.process(padded[start:end])
        enhanced = output[delay:delay + audio.size]
        if not np.isfinite(enhanced).all():
            raise ValueError("Processing returned non-finite samples; no output was written.")
        pcm = (np.clip(enhanced, -1.0, 32767 / 32768) * 32768).astype("<i2")
        with wave.open("enhanced.wav", "wb") as destination:
            destination.setnchannels(1)
            destination.setsampwidth(2)
            destination.setframerate(16000)
            destination.writeframes(pcm.tobytes())
        print(f"SDK {aic.get_sdk_version()}, model {model.get_id()}")
        print(f"Processed {audio.size} samples at 16000 Hz; wrote enhanced.wav")
    finally:
        processor.terminate_session()


if __name__ == "__main__":
    try:
        main()
    except Exception as error:
        message = getattr(error, "message", str(error))
        print(f"{type(error).__name__}: {message}", file=sys.stderr)
        sys.exit(1)