test_websocket_client.py

#!/usr/bin/env python3
"""Test WebSocket client for streaming ASR server."""

import asyncio
import json
import os
import sys
import time
import wave

import numpy as np
import websockets

import soundfile as sf

def _ensure_wav_16k_mono(input_path: str, output_path: str = "") -> str:
    src = os.path.abspath(input_path)
    if output_path:
        dst = os.path.abspath(output_path)
    else:
        base, _ = os.path.splitext(src)
        dst = base + "_16k_mono.wav"

    if os.path.exists(dst):
        try:
            if os.path.getmtime(dst) >= os.path.getmtime(src):
                return dst
        except OSError:
            pass

    audio, sr = sf.read(src, dtype="float32", always_2d=False)
    audio = np.asarray(audio, dtype=np.float32)
    sr = int(sr)

    if audio.ndim == 2:
        if audio.shape[0] <= 8 and audio.shape[1] > audio.shape[0]:
            audio = audio.T
        audio = np.mean(audio, axis=-1).astype(np.float32)

    if sr != 16000:
        if audio.shape[0] == 0:
            audio16 = audio.astype(np.float32, copy=False)
        else:
            dur = audio.shape[0] / float(sr)
            n16 = int(round(dur * 16000))
            if n16 <= 0:
                audio16 = np.zeros((0,), dtype=np.float32)
            else:
                x_old = np.linspace(0.0, dur, num=audio.shape[0], endpoint=False)
                x_new = np.linspace(0.0, dur, num=n16, endpoint=False)
                audio16 = np.interp(x_new, x_old, audio).astype(np.float32)
    else:
        audio16 = audio.astype(np.float32, copy=False)

    sf.write(dst, audio16, 16000, subtype="PCM_16")
    return dst


async def test_asr_streaming(
    audio_path: str,
    server_url: str = "ws://localhost:8080",
    chunk_ms: int = 500,
):
    """Send audio file to streaming ASR server and show interim results."""

    print(f"Reading audio file: {audio_path}")

    # Read WAV file
    with wave.open(audio_path, 'rb') as wf:
        sample_rate = wf.getframerate()
        n_channels = wf.getnchannels()
        sample_width = wf.getsampwidth()
        n_frames = wf.getnframes()
        audio_data = wf.readframes(n_frames)

    duration = n_frames / sample_rate
    print(f"  Sample rate: {sample_rate} Hz")
    print(f"  Channels: {n_channels}")
    print(f"  Duration: {duration:.2f}s")
    print(f"  Size: {len(audio_data)} bytes")

    # Calculate chunk size in bytes (16kHz, 16-bit = 2 bytes/sample)
    chunk_samples = int(sample_rate * chunk_ms / 1000)
    chunk_bytes = chunk_samples * sample_width  # sample_width = 2 for 16-bit

    print(f"\nChunk size: {chunk_ms}ms = {chunk_samples} samples = {chunk_bytes} bytes")
    print(f"Connecting to {server_url}...")

    start_time = time.time()

    async with websockets.connect(server_url) as ws:
        connect_time = time.time()
        print(f"  Connected in {(connect_time - start_time)*1000:.0f}ms")

        # Wait for ready message
        ready_msg = await ws.recv()
        ready_data = json.loads(ready_msg)
        if ready_data.get("type") != "ready":
            print(f"  WARNING: Expected 'ready', got: {ready_data}")
        else:
            print(f"  Server ready")

        ready_time = time.time()

        # Track interim results
        interim_count = 0
        last_interim = ""

        # Create a task to receive messages
        async def receive_messages():
            nonlocal interim_count, last_interim
            try:
                async for message in ws:
                    data = json.loads(message)
                    if data.get("type") == "transcript":
                        text = data.get("text", "")
                        is_final = data.get("is_final", False)

                        if is_final:
                            return text
                        else:
                            interim_count += 1
                            last_interim = text
                            # Show interim result (truncated)
                            display = text[:60] + "..." if len(text) > 60 else text
                            print(f"  [interim {interim_count}] {display}")
                    elif data.get("type") == "error":
                        print(f"  ERROR: {data.get('message')}")
                        return None
            except websockets.exceptions.ConnectionClosed:
                return last_interim

        # Start receiving in background
        receive_task = asyncio.create_task(receive_messages())

        # Send audio data in chunks
        total_sent = 0
        chunks_sent = 0

        print(f"\nSending audio in {chunk_ms}ms chunks...")
        send_start = time.time()

        for i in range(0, len(audio_data), chunk_bytes):
            chunk = audio_data[i:i+chunk_bytes]
            await ws.send(chunk)
            total_sent += len(chunk)
            chunks_sent += 1

            # Simulate real-time streaming
            await asyncio.sleep(chunk_ms / 1000)

        send_time = time.time()
        print(f"  Sent {chunks_sent} chunks ({total_sent} bytes) in {(send_time - send_start)*1000:.0f}ms")

        # Record time of last audio chunk sent
        last_audio_time = send_time

        # Signal end of audio
        end_signal_time = time.time()
        await ws.send(json.dumps({"type": "reset"}))

        # Wait for final transcript
        print("\nWaiting for final transcript...")
        transcript = await receive_task
        final_recv_time = time.time()

        # Calculate time-to-final-transcription
        time_to_final = (final_recv_time - last_audio_time) * 1000
        end_signal_to_final = (final_recv_time - end_signal_time) * 1000

        print(f"\n{'='*60}")
        print("FINAL TRANSCRIPT:")
        print(f"{'='*60}")
        print(transcript if transcript else "(empty)")
        print(f"{'='*60}")

        total_time = final_recv_time - start_time
        print(f"\nStatistics:")
        print(f"  Interim results: {interim_count}")
        print(f"  Total time: {total_time*1000:.0f}ms")
        print(f"  Audio duration: {duration:.2f}s")
        print(f"  Real-time factor: {total_time/duration:.2f}x")
        print(f"\nFinalization latency:")
        print(f"  Last audio chunk -> final transcript: {time_to_final:.0f}ms")
        print(f"  End signal -> final transcript: {end_signal_to_final:.0f}ms")

        return transcript


async def test_multiple_chunk_sizes(audio_path: str, server_url: str):
    """Test with different chunk sizes."""
    print("=" * 60)
    print("Testing Multiple Chunk Sizes")
    print("=" * 60)

    for chunk_ms in [500, 160, 80]:
        print(f"\n{'='*60}")
        print(f"CHUNK SIZE: {chunk_ms}ms")
        print(f"{'='*60}")

        try:
            await test_asr_streaming(audio_path, server_url, chunk_ms)
        except Exception as e:
            print(f"ERROR with {chunk_ms}ms chunks: {e}")

        # Small delay between tests
        await asyncio.sleep(1)


if __name__ == "__main__":

    import sys
    # sys.argv.append( '--all' )

    mp3_path = "./common_voice_en_444.mp3"

    audio_path = _ensure_wav_16k_mono(mp3_path)

    server_url = "ws://127.0.0.1:8080"

    # Check for --all flag to test all chunk sizes
    if "--all" in sys.argv:
        asyncio.run(test_multiple_chunk_sizes(audio_path, server_url))
    else:
        chunk_ms = 200
        if "--chunk" in sys.argv:
            idx = sys.argv.index("--chunk")
            if idx + 1 < len(sys.argv):
                chunk_ms = int(sys.argv[idx + 1])

        asyncio.run(test_asr_streaming(audio_path, server_url, chunk_ms))