speechflow 1.3.1 → 1.4.0

package/src/speechflow-node-a2t-deepgram.ts

@@ -1,234 +0,0 @@
-/*
-**  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-
-/*  standard dependencies  */
-import Stream from "node:stream"
-
-/*  external dependencies  */
-import * as Deepgram          from "@deepgram/sdk"
-import { DateTime, Duration } from "luxon"
-
-/*  internal dependencies  */
-import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
-import * as utils                          from "./speechflow-utils"
-
-/*  SpeechFlow node for Deepgram speech-to-text conversion  */
-export default class SpeechFlowNodeDeepgram extends SpeechFlowNode {
-    /*  declare official node name  */
-    public static name = "deepgram"
-
-    /*  internal state  */
-    private dg: Deepgram.LiveClient | null = null
-
-    /*  construct node  */
-    constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
-        super(id, cfg, opts, args)
-
-        /*  declare node configuration parameters  */
-        this.configure({
-            key:      { type: "string", val: process.env.SPEECHFLOW_DEEPGRAM_KEY },
-            keyAdm:   { type: "string", val: process.env.SPEECHFLOW_DEEPGRAM_KEY_ADM },
-            model:    { type: "string", val: "nova-3", pos: 0 },
-            version:  { type: "string", val: "latest", pos: 1 },
-            language: { type: "string", val: "multi",  pos: 2 }
-        })
-
-        /*  declare node input/output format  */
-        this.input  = "audio"
-        this.output = "text"
-    }
-
-    /*  one-time status of node  */
-    async status () {
-        let balance  = 0
-        const deepgram = Deepgram.createClient(this.params.keyAdm)
-        const response = await deepgram.manage.getProjects()
-        if (response !== null && response.error === null) {
-            for (const project of response.result.projects) {
-                const response = await deepgram.manage.getProjectBalances(project.project_id)
-                if (response !== null && response.error === null)
-                    balance += response.result.balances[0]?.amount ?? 0
-            }
-        }
-        return { balance: balance.toFixed(2) }
-    }
-
-    /*  open node  */
-    async open () {
-        /*  sanity check situation  */
-        if (this.config.audioBitDepth !== 16 || !this.config.audioLittleEndian)
-            throw new Error("Deepgram node currently supports PCM-S16LE audio only")
-
-        /*  create queue for results  */
-        const queue = new utils.SingleQueue<SpeechFlowChunk>()
-
-        /*  create a store for the meta information  */
-        const metastore = new utils.TimeStore<Map<string, any>>()
-
-        /*  connect to Deepgram API  */
-        const deepgram = Deepgram.createClient(this.params.key)
-        let language = "en"
-        if (this.params.model.match(/^nova-2/) && this.params.language !== "en")
-            language = this.params.language
-        else if (this.params.model.match(/^nova-3/) && this.params.language !== "en")
-            language = "multi"
-        this.dg = deepgram.listen.live({
-            mip_opt_out:      true,
-            model:            this.params.model,
-            version:          this.params.version,
-            language,
-            channels:         this.config.audioChannels,
-            sample_rate:      this.config.audioSampleRate,
-            encoding:         "linear16",
-            multichannel:     false,
-            endpointing:      10,
-            interim_results:  false,
-            smart_format:     true,
-            punctuate:        true,
-            filler_words:     true,
-            diarize:          false,
-            numerals:         true,
-            profanity_filter: false
-        })
-
-        /*  hook onto Deepgram API events  */
-        this.dg.on(Deepgram.LiveTranscriptionEvents.Transcript, async (data) => {
-            const text  = (data.channel?.alternatives[0]?.transcript ?? "") as string
-            const words = (data.channel?.alternatives[0]?.words ?? []) as
-                { word: string, punctuated_word?: string, start: number, end: number }[]
-            if (text === "")
-                this.log("info", `empty/dummy text received (start: ${data.start}s, duration: ${data.duration.toFixed(2)}s)`)
-            else {
-                this.log("info", `text received (start: ${data.start}s, duration: ${data.duration.toFixed(2)}s): "${text}"`)
-                const start = Duration.fromMillis(data.start * 1000).plus(this.timeZeroOffset)
-                const end   = start.plus({ seconds: data.duration })
-                const metas = metastore.fetch(start, end)
-                const meta = metas.reduce((prev: Map<string, any>, curr: Map<string, any>) => {
-                    curr.forEach((val, key) => { prev.set(key, val) })
-                    return prev
-                }, new Map<string, any>())
-                metastore.prune(start)
-                meta.set("words", words.map((word) => {
-                    const start = Duration.fromMillis(word.start * 1000).plus(this.timeZeroOffset)
-                    const end   = Duration.fromMillis(word.end * 1000).plus(this.timeZeroOffset)
-                    return { word: word.punctuated_word ?? word.word, start, end }
-                }))
-                const chunk = new SpeechFlowChunk(start, end, "final", "text", text, meta)
-                queue.write(chunk)
-            }
-        })
-        this.dg.on(Deepgram.LiveTranscriptionEvents.Metadata, (data) => {
-            this.log("info", "metadata received")
-        })
-        this.dg.on(Deepgram.LiveTranscriptionEvents.Close, () => {
-            this.log("info", "connection close")
-        })
-        this.dg.on(Deepgram.LiveTranscriptionEvents.Error, (error: Error) => {
-            this.log("error", `error: ${error.message}`)
-            this.emit("error")
-        })
-
-        /*  wait for Deepgram API to be available  */
-        await new Promise((resolve, reject) => {
-            let timer: ReturnType<typeof setTimeout> | null = setTimeout(() => {
-                if (timer !== null) {
-                    timer = null
-                    reject(new Error("Deepgram: timeout waiting for connection open"))
-                }
-            }, 8000)
-            this.dg!.once(Deepgram.LiveTranscriptionEvents.Open, () => {
-                this.log("info", "connection open")
-                if (timer !== null) {
-                    clearTimeout(timer)
-                    timer = null
-                }
-                resolve(true)
-            })
-        })
-
-        /*  remember opening time to receive time zero offset  */
-        this.timeOpen = DateTime.now()
-
-        /*  workaround Deepgram initialization problems  */
-        let initDone = false
-        let initTimeout: ReturnType<typeof setTimeout> | null = null
-        const initTimeoutStart = () => {
-            if (initDone)
-                return
-            setTimeout(async () => {
-                if (initTimeout === null)
-                    return
-                initTimeout = null
-                this.log("warning", "initialization timeout -- restarting service usage")
-                await this.close()
-                this.open()
-            }, 3000)
-        }
-        const initTimeoutStop = () => {
-            if (initDone)
-                return
-            initDone = true
-            if (initTimeout !== null) {
-                clearTimeout(initTimeout)
-                initTimeout = null
-            }
-        }
-
-        /*  provide Duplex stream and internally attach to Deepgram API  */
-        const dg = this.dg
-        const log = (level: string, msg: string) => {
-            this.log(level, msg)
-        }
-        const encoding = this.config.textEncoding
-        this.stream = new Stream.Duplex({
-            writableObjectMode: true,
-            readableObjectMode: true,
-            decodeStrings:      false,
-            highWaterMark:      1,
-            write (chunk: SpeechFlowChunk, encoding, callback) {
-                if (chunk.type !== "audio")
-                    callback(new Error("expected audio input chunk"))
-                else if (!Buffer.isBuffer(chunk.payload))
-                    callback(new Error("expected Buffer input chunk"))
-                else {
-                    if (chunk.payload.byteLength > 0) {
-                        log("debug", `send data (${chunk.payload.byteLength} bytes)`)
-                        initTimeoutStart()
-                        if (chunk.meta.size > 0)
-                            metastore.store(chunk.timestampStart, chunk.timestampEnd, chunk.meta)
-                        dg.send(chunk.payload.buffer) /* intentionally discard all time information  */
-                    }
-                    callback()
-                }
-            },
-            read (size) {
-                queue.read().then((chunk) => {
-                    log("info", `receive data (${chunk.payload.length} bytes)`)
-                    initTimeoutStop()
-                    this.push(chunk, encoding)
-                })
-            },
-            final (callback) {
-                dg.requestClose()
-                this.push(null)
-                callback()
-            }
-        })
-    }
-
-    /*  close node  */
-    async close () {
-        /*  close stream  */
-        if (this.stream !== null) {
-            this.stream.destroy()
-            this.stream = null
-        }
-
-        /*  shutdown Deepgram API  */
-        if (this.dg !== null)
-            this.dg.requestClose()
-    }
-}

package/src/speechflow-node-t2t-subtitle.ts

@@ -1,149 +0,0 @@
-/*
-**  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-
-/*  standard dependencies  */
-import Stream from "node:stream"
-
-/*  external dependencies  */
-import { Duration } from "luxon"
-
-/*  internal dependencies  */
-import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
-
-/*  SpeechFlow node for subtitle (text-to-text) "translations"  */
-export default class SpeechFlowNodeSubtitle extends SpeechFlowNode {
-    /*  declare official node name  */
-    public static name = "subtitle"
-
-    /*  internal state  */
-    private sequenceNo = 1
-
-    /*  construct node  */
-    constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
-        super(id, cfg, opts, args)
-
-        /*  declare node configuration parameters  */
-        this.configure({
-            format: { type: "string", pos: 0, val: "srt", match: /^(?:srt|vtt)$/ },
-            words:  { type: "boolean", val: false }
-        })
-
-        /*  declare node input/output format  */
-        this.input  = "text"
-        this.output = "text"
-    }
-
-    /*  open node  */
-    async open () {
-        this.sequenceNo = 1
-
-        /*  provide text-to-subtitle conversion  */
-        const convert = async (chunk: SpeechFlowChunk) => {
-            if (typeof chunk.payload !== "string")
-                throw new Error("chunk payload type must be string")
-            const convertSingle = (
-                start:      Duration,
-                end:        Duration,
-                text:       string,
-                word?:      string,
-                occurence?: number
-            ) => {
-                if (word) {
-                    occurence ??= 1
-                    let match = 1
-                    word = word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-                    text = text.replaceAll(new RegExp(`\\b${word}\\b`, "g"), (m) => {
-                        if (match++ === occurence)
-                            return `<b>${m}</b>`
-                        else
-                            return m
-                    })
-                }
-                if (this.params.format === "srt") {
-                    const startFmt = start.toFormat("hh:mm:ss,SSS")
-                    const endFmt   = end.toFormat("hh:mm:ss,SSS")
-                    text = `${this.sequenceNo++}\n` +
-                        `${startFmt} --> ${endFmt}\n` +
-                        `${text}\n\n`
-                }
-                else if (this.params.format === "vtt") {
-                    const startFmt = start.toFormat("hh:mm:ss.SSS")
-                    const endFmt   = end.toFormat("hh:mm:ss.SSS")
-                    text = `${startFmt} --> ${endFmt}\n` +
-                        `${text}\n\n`
-                }
-                return text
-            }
-            let output = ""
-            if (this.params.words) {
-                output += convertSingle(chunk.timestampStart, chunk.timestampEnd, chunk.payload)
-                const words = (chunk.meta.get("words") ?? []) as
-                    { word: string, start: Duration, end: Duration }[]
-                const occurences = new Map<string, number>()
-                for (const word of words) {
-                    let occurence = occurences.get(word.word) ?? 0
-                    occurence++
-                    occurences.set(word.word, occurence)
-                    output += convertSingle(word.start, word.end, chunk.payload, word.word, occurence)
-                }
-            }
-            else
-                output += convertSingle(chunk.timestampStart, chunk.timestampEnd, chunk.payload)
-            return output
-        }
-
-        /*  establish a duplex stream  */
-        const self = this
-        let firstChunk = true
-        this.stream = new Stream.Transform({
-            readableObjectMode: true,
-            writableObjectMode: true,
-            decodeStrings:      false,
-            highWaterMark:      1,
-            transform (chunk: SpeechFlowChunk, encoding, callback) {
-                if (firstChunk && self.params.format === "vtt") {
-                    this.push(new SpeechFlowChunk(
-                        Duration.fromMillis(0), Duration.fromMillis(0),
-                        "final", "text",
-                        "WEBVTT\n\n"
-                    ))
-                    firstChunk = false
-                }
-                if (Buffer.isBuffer(chunk.payload))
-                    callback(new Error("invalid chunk payload type"))
-                else {
-                    if (chunk.payload === "") {
-                        this.push(chunk)
-                        callback()
-                    }
-                    else {
-                        convert(chunk).then((payload) => {
-                            const chunkNew = chunk.clone()
-                            chunkNew.payload = payload
-                            this.push(chunkNew)
-                            callback()
-                        }).catch((err) => {
-                            callback(err)
-                        })
-                    }
-                }
-            },
-            final (callback) {
-                this.push(null)
-                callback()
-            }
-        })
-    }
-
-    /*  open node  */
-    async close () {
-        /*  close stream  */
-        if (this.stream !== null) {
-            this.stream.destroy()
-            this.stream = null
-        }
-    }
-}