source: main/trunk/model-interfaces-dev/atea/js/asr/TranscribeModule.js@ 35284

/**
 * @file Defines components that are used to interact with the transcription proxy servlet.
 * @author Carl Stephens
 * @module
 */

export class TranscriptionModel
{
    /**
     * The transcription object returned from our transcription endpoint.
     * 
     * @param {String} file_name The name of the file that was transcribed.
     * @param {String} log A note of how the transcription was processed.
     * @param {{char: String, confidence: Number, start_time: Number}[]} metadata The character metadata.
     * @param {boolean} success A value indicating if the transcription was successful or not.
     * @param {String} transcription The transcription.
     */
    constructor(file_name, log, metadata, success, transcription)
    {
        this.file_name = file_name;
        this.log = log;
        this.metadata = metadata;
        this.success = success;
        this.transcription = transcription;
    }
}

export class TranscriptionError extends Error
{
    /**
     * Initialises a new instance of the {@link TranscriptionError} object.
     * 
     * @param {Number | undefined} statusCode The HTTP status code of the error.
     * @param {String | undefined} message The status message.
     * @param {String | null} file The file on which the transcription failed.
     */
    constructor(message = undefined, file = null, statusCode = -1)
    {
        super(message);
        //this.message = message;

        this.file = file;
        this.statusCode = statusCode;
    }
}

/**
 * A service that uploads audio files in a multipart request to the Korero Maori API Interface servlet, and interprets the result.
 */
export class TranscribeService
{
    constructor()
    {
        /** @type {String} The URL to which query POST requests should be made. */
        this.queryUrl = "/gs3-koreromaori/transcribe/test";

        /** @type {Number} The maximum number of files which can be transcribed in one request to the API. */
        this.MAX_BATCH_COUNT = 3;

        /** @type {Number} The soft upper limit on how many bytes can be submitted in one request. */
        this.BATCH_BYTE_LIMIT = 5242880; // 5 MiB
    }

    /**
     * Performs chunked queries to transcribe the given audio files, returning the data in iterations.
     * Data is chunked according to which ever occurs first:
     * A maximum of three files per request, or;
     * A maximum of 5 MiB before chunking.
     * 
     * @param {FileList} files The files to upload
     * @returns {AsyncGenerator<TranscriptionModel[]>} The transcribed audio files.
     * @throws {TranscriptionError} When the transcription request fails to complete.
     */
    async* batchTranscribeFiles(files)
    {
        let filesToSubmit = [];
        let fileCounter = 0;
        let byteCounter = 0;

        for (let file of files)
        {
            if (fileCounter == this.MAX_BATCH_COUNT || byteCounter > this.BATCH_BYTE_LIMIT) // 5 MiB
            {
                yield await this.transcribeFiles(filesToSubmit);
                filesToSubmit = [];
                byteCounter = 0;
                fileCounter = 0;
            }

            filesToSubmit[fileCounter++] = file;
            byteCounter += file.size;
        }

        if (filesToSubmit.length > 0) {
            yield await this.transcribeFiles(filesToSubmit);
        }
    }

    /**
     * Performs a query to transcribe the given audio files.
     * 
     * @param {FileList | File[]} files The files to upload.
     * @returns {Promise<TranscriptionModel[]>} The transcribed audio file.
     * @throws {TranscriptionError} When the transcription request fails to complete.
     */
    async transcribeFiles(files)
    {
        const that = this;
        const formData = new FormData();

        let audioFileKeys = "";
        for (let i = 0; i < files.length; i++)
        {
            const f = files[i];
            const key = "audioFile" + i;

            formData.append(key, f, f.name);
            audioFileKeys += key + "|";
        }
        formData.append("audioFileKeys", audioFileKeys);

        let response;
        try
        {
            response = await fetch(
                that.queryUrl, 
                {
                    method: "POST",
                    body: formData
                }
            );
        }
        catch (e)
        {
            console.error(`Transcription failed with reason ${e}`);
            throw new TranscriptionError(undefined, "Unknown");
        }

        if (!response.ok)
        {
            console.error(`Transcription API failed with status ${response.status} and message ${response.statusText}`);
            throw new TranscriptionError(response.statusText, undefined, response.status);
        }
        
        return await response.json();
    }

    // OBSOLETE. Kept for reference purposes on XMLHttpRequest usage. See transcribeFiles instead.
    //
    // Based on https://stackoverflow.com/questions/2320069/jquery-ajax-file-upload
    // doUpload(files, resultCallback, progressCallback)
    // {
    //     let that = this;
    //     let formData = new FormData();

    //     let audioFileKeys = "";
    //     for (let f of files)
    //     {
    //         formData.append(f.name, f, f.name);
    //         audioFileKeys += f.name + "|";
    //     }
    //     formData.append("audioFileKeys", audioFileKeys);

    //     $.ajax({
    //         type: "POST",
    //         url: this.queryUrl,
    //         xhr: function ()
    //         {
    //             var myXhr = $.ajaxSettings.xhr();
    //             if (myXhr.upload && progressCallback != undefined)
    //             {
    //                 myXhr.upload.addEventListener("progress", progressCallback, false);
    //             }
    //             return myXhr;
    //         },
    //         success: function (data)
    //         {
    //             resultCallback(data);
    //         },
    //         error: function (error)
    //         {
    //             console.error("Failed to upload file via AJAX POST: " + error);
    //         },
    //         async: true,
    //         data: formData,
    //         cache: false,
    //         contentType: false,
    //         processData: false,
    //         timeout: 60000 // TODO: Consider if we need a longer timeout.
    //     });
    // }
}