Transcribe Streams

from typing import Iterable
from soniox.transcribe_live import transcribe_stream
from soniox.speech_service import SpeechClient, set_api_key

set_api_key("<YOUR-API-KEY>")


def iter_audio() -> Iterable[bytes]:
    # This function should yield audio bytes from your stream.

    # Here we simulate the stream by reading a file in small chunks.
    with open("../test_data/test_audio_long.flac", "rb") as fh:
        while True:
            audio = fh.read(1024)
            if len(audio) == 0:
                break
            yield audio


def main():
    with SpeechClient() as client:
        for result in transcribe_stream(iter_audio(), client):
            print(" ".join(w.text for w in result.words))


if __name__ == "__main__":
    main()

python3 transcribe_any_stream.py

But
But there
But there is
But there is always
But there is always a
But there is always a strong
But there is always a stronger
But there is always a stronger sense
But there is always a stronger sense of
But there is always a stronger sense of life
But there is always a stronger sense of life

const fs = require("fs");
const { SpeechClient } = require("@soniox/soniox-node");

// Do not forget to set your Soniox API key.
const speechClient = new SpeechClient();

(async function () {
    const onDataHandler = async (result) => {
        console.log(`Words: ${result.words.map((word) => word.text).join(" ")}`);
    };

    const onEndHandler = (error) => {
        console.log("END!", error);
    };

    // transcribeStream() returns object with ".writeAsync()" and ".end()" methods.
    // Use them to send data and end the stream when done.
    const stream = speechClient.transcribeStream(
        { include_nonfinal: true },
        onDataHandler,
        onEndHandler
    );

    // Here we simulate the stream by reading a file in small chunks.
    const CHUNK_SIZE = 1024;
    const readable = fs.createReadStream("../test_data/test_audio_long.flac", {
        highWaterMark: CHUNK_SIZE,
    });

    for await (const chunk of readable) {
        await stream.writeAsync(chunk);
    }

    stream.end();
})();    

node transcribe_any_stream.js

Words: 
Words: But
Words: But there
Words: But there is
Words: But there is always
Words: But there is always a
Words: But there is always a strong
Words: But there is always a stronger
Words: But there is always a stronger sense
Words: But there is always a stronger sense of
Words: But there is always a stronger sense of life
Words: But there is always a stronger sense of life

using System.Linq;
using System.Runtime.CompilerServices;
using Soniox.Types;
using Soniox.Client;
using Soniox.Client.Proto;

using var client = new SpeechClient();

// TranscribeStream requires the user to provide the audio to transcribe
// as an IAsyncEnumerable<bytes[]> instance. This can be implemented as
// an async function that uses "yield return". This example function
// reads a file in chunks.
async IAsyncEnumerable<byte[]> EnumerateAudioChunks(
    [EnumeratorCancellation] CancellationToken cancellationToken = default(CancellationToken)
)
{
    string filePath = "../../test_data/test_audio_long.flac";
    int bufferSize = 1024;

    await using var fileStream = new FileStream(
        filePath, FileMode.Open, FileAccess.Read, FileShare.Read,
        bufferSize: bufferSize, useAsync: true
    );

    while (true)
    {
        byte[] buffer = new byte[bufferSize];
        int numRead = await fileStream.ReadAsync(buffer, cancellationToken);
        if (numRead == 0)
        {
            break;
        }
        Array.Resize(ref buffer, numRead);
        yield return buffer;
    }
}

IAsyncEnumerable<Result> resultsEnumerable = client.TranscribeStream(
    EnumerateAudioChunks(),
    new TranscriptionConfig
    {
        IncludeNonfinal = true,
    });

await foreach (var result in resultsEnumerable)
{
    // Note result.Words contains final and non-final words,
    // we do not print this this information in this example.
    var wordsStr = string.Join(" ", result.Words.Select(word => word.Text).ToArray());
    Console.WriteLine($"Words: {wordsStr}");
}

cd soniox_examples/csharp/TranscribeAnyStream
dotnet run

Words: 
Words: But
Words: But there
Words: But there is
Words: But there is always
Words: But there is always a
Words: But there is always a strong
Words: But there is always a stronger
Words: But there is always a stronger sense
Words: But there is always a stronger sense of
Words: But there is always a stronger sense of life
Words: But there is always a stronger sense of life

for result in transcribe_stream(
        iter_audio(), 
        client, 
        audio_format="pcm_s16le",
        sample_rate_hertz=16000,
        num_audio_channels=1):

const stream = speechClient.transcribeStream(
    { 
        audio_format: "pcm_s16le",
        sample_rate_hertz: 16000,
        num_audio_channels: 1,
        include_nonfinal: true
    },
    onDataHandler,
    onEndHandler
);

IAsyncEnumerable<Result> resultsEnumerable = client.TranscribeStream(
    EnumerateAudioChunks(),
    new TranscriptionConfig
    {
        IncludeNonfinal = true,
        AudioFormat = "pcm_s16le",
        SampleRateHertz = 16000,
        NumAudioChannels = 1,
    });