@xrkseek/harness 0.7.7 → 0.7.8

package/node_modules/sherpa-onnx-node/speaker-identification.js

@@ -0,0 +1,152 @@
+/** @typedef {import('./types').SpeakerEmbeddingEntry} SpeakerEmbeddingEntry */
+/** @typedef {import('./types').SpeakerEmbeddingManagerSearchObj} SpeakerEmbeddingManagerSearchObj */
+/** @typedef {import('./types').SpeakerEmbeddingManagerVerifyObj} SpeakerEmbeddingManagerVerifyObj */
+/** @typedef {import('./types').SpeakerEmbeddingExtractorConfig} SpeakerEmbeddingExtractorConfig */
+/** @typedef {import('./types').SpeakerEmbeddingExtractorHandle} SpeakerEmbeddingExtractorHandle */
+/** @typedef {import('./types').SpeakerEmbeddingManagerHandle} SpeakerEmbeddingManagerHandle */
+/** @typedef {import('./streaming-asr').OnlineStream} OnlineStream */
+
+const addon = require('./addon.js');
+const streaming_asr = require('./streaming-asr.js');
+
+/**
+ * SpeakerEmbeddingExtractor wraps native speaker embedding extractor.
+ */
+class SpeakerEmbeddingExtractor {
+  /**
+   * @param {SpeakerEmbeddingExtractorConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createSpeakerEmbeddingExtractor(config);
+    this.config = config;
+    this.dim = addon.speakerEmbeddingExtractorDim(this.handle);
+  }
+
+  /**
+   * @returns {OnlineStream}
+   */
+  createStream() {
+    return new streaming_asr.OnlineStream(
+        addon.speakerEmbeddingExtractorCreateStream(this.handle));
+  }
+
+  /**
+   * @param {OnlineStream} stream
+   * @returns {boolean}
+   */
+  isReady(stream) {
+    return addon.speakerEmbeddingExtractorIsReady(this.handle, stream.handle);
+  }
+
+  /**
+   * Compute embedding and return a Float32Array
+   * @param {OnlineStream} stream
+   * @param {boolean} [enableExternalBuffer=true]
+   * @returns {Float32Array}
+   */
+  compute(stream, enableExternalBuffer = true) {
+    return addon.speakerEmbeddingExtractorComputeEmbedding(
+        this.handle, stream.handle, enableExternalBuffer);
+  }
+}
+
+/**
+ * Flattens an array of Float32Arrays into a single Float32Array.
+ * @param {Float32Array[]} arrayList
+ * @returns {Float32Array}
+ */
+function flatten(arrayList) {
+  let n = 0;
+  for (let i = 0; i < arrayList.length; ++i) {
+    n += arrayList[i].length;
+  }
+  let ans = new Float32Array(n);
+
+  let offset = 0;
+  for (let i = 0; i < arrayList.length; ++i) {
+    ans.set(arrayList[i], offset);
+    offset += arrayList[i].length;
+  }
+  return ans;
+}
+
+/**
+ * Manager for speaker embeddings.
+ */
+class SpeakerEmbeddingManager {
+  /**
+   * @param {number} dim - The embedding dimension
+   */
+  constructor(dim) {
+    this.handle = addon.createSpeakerEmbeddingManager(dim);
+    this.dim = dim;
+  }
+
+  /**
+   * @param {SpeakerEmbeddingEntry} obj
+   * @returns {boolean}
+   */
+  add(obj) {
+    return addon.speakerEmbeddingManagerAdd(this.handle, obj);
+  }
+
+  /**
+   * @param {{name:string, v: Float32Array[]}} obj
+   * @returns {boolean}
+   */
+  addMulti(obj) {
+    const c = {
+      name: obj.name,
+      vv: flatten(obj.v),
+      n: obj.v.length,
+    };
+    return addon.speakerEmbeddingManagerAddListFlattened(this.handle, c);
+  }
+
+  /**
+   * @param {string} name
+   * @returns {boolean}
+   */
+  remove(name) {
+    return addon.speakerEmbeddingManagerRemove(this.handle, name);
+  }
+
+  /**
+   * @param {SpeakerEmbeddingManagerSearchObj} obj
+   * @returns {string}
+   */
+  search(obj) {
+    return addon.speakerEmbeddingManagerSearch(this.handle, obj);
+  }
+
+  /**
+   * @param {SpeakerEmbeddingManagerVerifyObj} obj
+   * @returns {boolean}
+   */
+  verify(obj) {
+    return addon.speakerEmbeddingManagerVerify(this.handle, obj);
+  }
+
+  /**
+   * @param {string} name
+   * @returns {boolean}
+   */
+  contains(name) {
+    return addon.speakerEmbeddingManagerContains(this.handle, name);
+  }
+
+  /** @returns {number} */
+  getNumSpeakers() {
+    return addon.speakerEmbeddingManagerNumSpeakers(this.handle);
+  }
+
+  /** @returns {string[]} */
+  getAllSpeakerNames() {
+    return addon.speakerEmbeddingManagerGetAllSpeakers(this.handle);
+  }
+}
+
+module.exports = {
+  SpeakerEmbeddingExtractor,
+  SpeakerEmbeddingManager,
+}

package/node_modules/sherpa-onnx-node/spoken-language-identification.js

@@ -0,0 +1,38 @@
+/** @typedef {import('./types').SpokenLanguageIdentificationConfig} SpokenLanguageIdentificationConfig */
+/** @typedef {import('./types').SpokenLanguageIdentificationHandle} SpokenLanguageIdentificationHandle */
+/** @typedef {import('./non-streaming-asr').OfflineStream} OfflineStream */
+
+const addon = require('./addon.js');
+const non_streaming_asr = require('./non-streaming-asr.js');
+
+class SpokenLanguageIdentification {
+  /**
+   * @param {SpokenLanguageIdentificationConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createSpokenLanguageIdentification(config);
+    this.config = config;
+  }
+
+  /**
+   * @returns {OfflineStream}
+   */
+  createStream() {
+    return new non_streaming_asr.OfflineStream(
+        addon.createSpokenLanguageIdentificationOfflineStream(this.handle));
+  }
+
+  /**
+   * Return a 2-letter language code, e.g. 'en', 'de', 'fr', 'es', 'zh'
+   * @param {OfflineStream} stream
+   * @returns {string}
+   */
+  compute(stream) {
+    return addon.spokenLanguageIdentificationCompute(
+        this.handle, stream.handle);
+  }
+}
+
+module.exports = {
+  SpokenLanguageIdentification,
+} 

package/node_modules/sherpa-onnx-node/streaming-asr.js

@@ -0,0 +1,181 @@
+/** @typedef {import('./types').OnlineStreamObject} OnlineStreamObject */
+/** @typedef {import('./types').OnlineRecognizerHandle} OnlineRecognizerHandle */
+/** @typedef {import('./types').OnlineStreamHandle} OnlineStreamHandle */
+/** @typedef {import('./types').DisplayHandle} DisplayHandle */
+/** @typedef {import('./types').DisplayObject} DisplayObject */
+/** @typedef {import('./types').OnlineRecognizerConfig} OnlineRecognizerConfig */
+/** @typedef {import('./types').Waveform} Waveform */
+/** @typedef {import('./types').OnlineRecognizerResult} OnlineRecognizerResult */
+
+const addon = require('./addon.js');
+
+/**
+ * Display helper for printing recognized words.
+ */
+class Display {
+  /**
+   * @param {number} maxWordPerline
+   */
+  constructor(maxWordPerline) {
+    this.handle = addon.createDisplay(maxWordPerline);
+  }
+
+  /**
+   * Print text to display.
+   * @param {number} idx
+   * @param {string} text
+   */
+  print(idx, text) {
+    addon.print(this.handle, idx, text)
+  }
+}
+
+/**
+ * OnlineStream holds an active online stream handle.
+ */
+class OnlineStream {
+  /**
+   * @param {OnlineStreamObject|Object} handle - object with `handle` property
+   */
+  constructor(handle) {
+    this.handle = handle;
+  }
+
+  /**
+   * Accept waveform data
+   * @param {Waveform} obj - { samples: Float32Array, sampleRate: number }
+   */
+  acceptWaveform(obj) {
+    addon.acceptWaveformOnline(this.handle, obj)
+  }
+
+  /** Notify the stream input has finished. */
+  inputFinished() {
+    addon.inputFinished(this.handle)
+  }
+
+  /**
+   * Set a string option on the underlying online stream.
+   *
+   * For example, multilingual streaming Nemotron models read the option
+   * 'language' (e.g. 'en', 'de') from each stream on every decode call;
+   * leaving it unset selects automatic language detection.
+   * @param {string} key
+   * @param {string} value
+   */
+  setOption(key, value) {
+    addon.onlineStreamSetOption(this.handle, key, value);
+  }
+
+  /**
+   * Get a string option of the underlying online stream.
+   *
+   * Returns an empty string if the option has not been set; use hasOption()
+   * to distinguish an unset option from an empty value.
+   * @param {string} key
+   * @returns {string}
+   */
+  getOption(key) {
+    return addon.onlineStreamGetOption(this.handle, key);
+  }
+
+  /**
+   * Check whether an option has been set on the underlying online stream.
+   * @param {string} key
+   * @returns {boolean}
+   */
+  hasOption(key) {
+    return addon.onlineStreamHasOption(this.handle, key);
+  }
+}
+
+/**
+ * OnlineRecognizer wraps native online recognizer.
+ */
+class OnlineRecognizer {
+  /**
+   * @param {OnlineRecognizerConfig} config - online recognizer config (see C++ for fields)
+   */
+  constructor(config) {
+    this.handle = addon.createOnlineRecognizer(config);
+    this.config = config
+  }
+
+  /**
+   * Create a new OnlineStream.
+   * @returns {OnlineStream}
+   */
+  createStream() {
+    const handle = addon.createOnlineStream(this.handle);
+    return new OnlineStream(handle);
+  }
+
+  /**
+   * Check whether a stream is ready.
+   * @param {OnlineStream} stream
+   * @returns {boolean}
+   */
+  isReady(stream) {
+    return addon.isOnlineStreamReady(this.handle, stream.handle);
+  }
+
+  /**
+   * Trigger decoding on a stream.
+   * @param {OnlineStream} stream
+   */
+  decode(stream) {
+    addon.decodeOnlineStream(this.handle, stream.handle);
+  }
+
+  /**
+   * Decode multiple streams of this recognizer in parallel.
+   *
+   * The caller must ensure every stream in the array is ready for decoding,
+   * i.e. isReady() returns true for each of them.
+   * @param {OnlineStream[]} streams
+   */
+  decodeStreams(streams) {
+    const handles = streams.map((stream) => {
+      if (!(stream instanceof OnlineStream)) {
+        throw new TypeError('Every element should be an OnlineStream');
+      }
+      return stream.handle;
+    });
+    addon.decodeMultipleOnlineStreams(this.handle, handles);
+  }
+
+  /**
+   * Check endpoint condition for a stream.
+   * @param {OnlineStream} stream
+   * @returns {boolean}
+   */
+  isEndpoint(stream) {
+    return addon.isEndpoint(this.handle, stream.handle);
+  }
+
+  /**
+   * Reset a stream.
+   * @param {OnlineStream} stream
+   */
+  reset(stream) {
+    addon.reset(this.handle, stream.handle);
+  }
+
+  /**
+   * Get recognition result for a stream.
+   * @param {OnlineStream} stream
+   * @returns {OnlineRecognizerResult}
+   */
+  getResult(stream) {
+    const jsonStr =
+        addon.getOnlineStreamResultAsJson(this.handle, stream.handle);
+
+    return JSON.parse(jsonStr);
+  }
+}
+
+module.exports = {
+  OnlineRecognizer,
+  OnlineStream,
+  Display
+}