hume 0.15.2 → 0.15.3-beta.2

package/dist/wrapper/ensureSingleValidAudioTrack.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureSingleValidAudioTrack = void 0;
+/**
+ * Ensures that the given media stream contains exactly one valid audio track.
+ * Throws an error if no audio tracks are found, if there is more than one audio track,
+ * or if the sole audio track is falsy.
+ *
+ * @param {MediaStream} stream - The media stream object containing audio tracks to validate.
+ * @throws {Error} "No audio tracks" if the stream contains zero audio tracks.
+ * @throws {Error} "Multiple audio tracks" if the stream contains more than one audio track.
+ * @throws {Error} "No audio track" if the sole audio track is falsy.
+ */
+const ensureSingleValidAudioTrack = (stream) => {
+    const tracks = stream.getAudioTracks();
+    if (tracks.length === 0) {
+        throw new Error("No audio tracks available");
+    }
+    else if (tracks.length > 1) {
+        throw new Error("Multiple audio tracks found");
+    }
+    else if (!tracks[0]) {
+        throw new Error("The audio track is invalid");
+    }
+};
+exports.ensureSingleValidAudioTrack = ensureSingleValidAudioTrack;

package/dist/wrapper/expressionMeasurement/ExpressionMeasurementClient.d.ts

@@ -0,0 +1,9 @@
+import { ExpressionMeasurement as FernClient } from "../../api/resources/expressionMeasurement/client/Client";
+import { BatchClient } from "./batch/BatchClient";
+import { StreamClient } from "./streaming/StreamingClient";
+export declare class ExpressionMeasurement extends FernClient {
+    protected _batch: BatchClient | undefined;
+    get batch(): BatchClient;
+    protected _stream: StreamClient | undefined;
+    get stream(): StreamClient;
+}

package/dist/wrapper/expressionMeasurement/ExpressionMeasurementClient.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressionMeasurement = void 0;
+const Client_1 = require("../../api/resources/expressionMeasurement/client/Client");
+const BatchClient_1 = require("./batch/BatchClient");
+const StreamingClient_1 = require("./streaming/StreamingClient");
+class ExpressionMeasurement extends Client_1.ExpressionMeasurement {
+    // BatchClient here is overridden from the generated version, we wrap expression measurement jobs in
+    // a helper that makes it easier to await the result of a job.
+    get batch() {
+        var _a;
+        return ((_a = this._batch) !== null && _a !== void 0 ? _a : (this._batch = new BatchClient_1.BatchClient(this._options)));
+    }
+    get stream() {
+        var _a;
+        return ((_a = this._stream) !== null && _a !== void 0 ? _a : (this._stream = new StreamingClient_1.StreamClient(this._options)));
+    }
+}
+exports.ExpressionMeasurement = ExpressionMeasurement;

package/dist/wrapper/expressionMeasurement/batch/BatchClient.d.ts

@@ -0,0 +1,7 @@
+import { Batch as FernClient } from "../../../api/resources/expressionMeasurement/resources/batch/client/Client";
+import * as Hume from "../../../api";
+import { Job } from "./Job";
+import * as core from "../../../core";
+export declare class BatchClient extends FernClient {
+    startInferenceJob(request?: Hume.expressionMeasurement.batch.InferenceBaseRequest, requestOptions?: FernClient.RequestOptions): core.HttpResponsePromise<Job>;
+}

package/dist/wrapper/expressionMeasurement/batch/BatchClient.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchClient = void 0;
+const Client_1 = require("../../../api/resources/expressionMeasurement/resources/batch/client/Client");
+const Job_1 = require("./Job");
+const core = __importStar(require("../../../core"));
+class BatchClient extends Client_1.Batch {
+    // This just wraps the return value of the base class's `startInferenceJob` method
+    // and returns a `Job` instance (has helper functions to await the job's result) instead of a raw job ID.
+    startInferenceJob(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(super
+            .startInferenceJob(request, requestOptions)
+            .withRawResponse()
+            .then((result) => {
+            return { data: new Job_1.Job(result.data.jobId, this), rawResponse: result.rawResponse };
+        }));
+    }
+}
+exports.BatchClient = BatchClient;

package/dist/wrapper/expressionMeasurement/batch/Job.d.ts

@@ -0,0 +1,8 @@
+import * as Hume from "../../../api";
+import { BatchClient } from "./BatchClient";
+export declare class Job implements Hume.expressionMeasurement.batch.JobId {
+    readonly jobId: string;
+    private readonly client;
+    constructor(jobId: string, client: BatchClient);
+    awaitCompletion(timeoutInSeconds?: number): Promise<void>;
+}

package/dist/wrapper/expressionMeasurement/batch/Job.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Job = void 0;
+const errors = __importStar(require("../../../errors"));
+class Job {
+    constructor(jobId, client) {
+        this.jobId = jobId;
+        this.client = client;
+    }
+    awaitCompletion() {
+        return __awaiter(this, arguments, void 0, function* (timeoutInSeconds = 300) {
+            return new Promise((resolve, reject) => {
+                const poller = new JobCompletionPoller(this.jobId, this.client);
+                poller.start(resolve);
+                setTimeout(() => {
+                    poller.stop();
+                    reject(new errors.HumeTimeoutError("Timeout exceeded when polling for job completion"));
+                }, timeoutInSeconds * 1000);
+            });
+        });
+    }
+}
+exports.Job = Job;
+class JobCompletionPoller {
+    constructor(jobId, client) {
+        this.jobId = jobId;
+        this.client = client;
+        this.isPolling = true;
+    }
+    start(onTerminal) {
+        this.isPolling = true;
+        this.poll(onTerminal);
+    }
+    stop() {
+        this.isPolling = false;
+    }
+    poll(onTerminal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const jobDetails = yield this.client.getJobDetails(this.jobId);
+                if (jobDetails.state.status === "COMPLETED" || jobDetails.state.status === "FAILED") {
+                    onTerminal();
+                    this.stop();
+                }
+            }
+            catch (_a) {
+                // swallow errors while polling
+            }
+            if (this.isPolling) {
+                setTimeout(() => this.poll(onTerminal), 1000);
+            }
+        });
+    }
+}

package/dist/wrapper/expressionMeasurement/streaming/StreamSocket.d.ts

@@ -0,0 +1,72 @@
+import WebSocket from "ws";
+import * as Hume from "../../../api";
+import * as fs from "fs";
+export declare namespace StreamSocket {
+    interface Args {
+        websocket: WebSocket;
+        config: Hume.expressionMeasurement.stream.Config;
+        streamWindowMs?: number;
+    }
+}
+export declare class StreamSocket {
+    readonly websocket: WebSocket;
+    private readonly streamWindowMs?;
+    private config;
+    constructor({ websocket, config, streamWindowMs }: StreamSocket.Args);
+    /**
+     * Send file on the `StreamSocket`
+     *
+     * @param file A fs.ReadStream | File | Blob
+     * @param config This method is intended for use with a `LanguageConfig`.
+     * When the socket is configured for other modalities this method will fail.
+     */
+    sendFile({ file, config, }: {
+        file: fs.ReadStream | Blob;
+        config?: Hume.expressionMeasurement.stream.Config;
+    }): Promise<Hume.expressionMeasurement.stream.Config | Hume.expressionMeasurement.stream.StreamErrorMessage>;
+    /**
+     * Send text on the `StreamSocket`
+     *
+     * @param text Text to send to the language model.
+     * @param config This method is intended for use with a `LanguageConfig`.
+     * When the socket is configured for other modalities this method will fail.
+     */
+    sendText({ text, config, }: {
+        text: string;
+        config?: Hume.expressionMeasurement.stream.Config;
+    }): Promise<Hume.expressionMeasurement.stream.Config | Hume.expressionMeasurement.stream.StreamErrorMessage>;
+    /**
+     * Send facemesh landmarks on the `StreamSocket`
+     *
+     * @param landmarks List of landmark points for multiple faces.
+     * The shape of this 3-dimensional list should be (n, 478, 3) where n is the number
+     * of faces to be processed, 478 is the number of MediaPipe landmarks per face and 3
+     * represents the (x, y, z) coordinates of each landmark.
+     * @param config List of model configurations.
+     * If set these configurations will overwrite existing configurations
+     */
+    sendFacemesh({ landmarks, config, }: {
+        landmarks: number[][][];
+        config?: Hume.expressionMeasurement.stream.Config;
+    }): Promise<Hume.expressionMeasurement.stream.Config | Hume.expressionMeasurement.stream.StreamErrorMessage>;
+    /**
+     *
+     * Reset the streaming sliding window.
+     *
+     * Call this method when some media has been fully processed and you want to continue using the same
+     * streaming connection without leaking context across media samples.
+     */
+    reset(): Promise<void>;
+    /**
+     *
+     * Get details associated with the current streaming connection.
+     *
+     */
+    getJobDetails(): Promise<void>;
+    /**
+     * Closes the underlying socket.
+     */
+    close(): void;
+    private send;
+    private tillSocketOpen;
+}

package/dist/wrapper/expressionMeasurement/streaming/StreamSocket.js

@@ -0,0 +1,255 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamSocket = void 0;
+const ws_1 = __importDefault(require("ws"));
+const uuid_1 = require("uuid");
+const StreamingClient_1 = require("./StreamingClient");
+const base64Encode_1 = require("../../base64Encode");
+const errors = __importStar(require("../../../errors"));
+const serializers = __importStar(require("../../../serialization"));
+const fs = __importStar(require("fs"));
+class StreamSocket {
+    constructor({ websocket, config, streamWindowMs }) {
+        this.websocket = websocket;
+        this.config = config;
+        this.streamWindowMs = streamWindowMs;
+    }
+    /**
+     * Send file on the `StreamSocket`
+     *
+     * @param file A fs.ReadStream | File | Blob
+     * @param config This method is intended for use with a `LanguageConfig`.
+     * When the socket is configured for other modalities this method will fail.
+     */
+    sendFile(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ file, config, }) {
+            var _b, file_1, file_1_1;
+            var _c, e_1, _d, _e;
+            if (config != null) {
+                this.config = config;
+            }
+            let contents = "";
+            if (file instanceof fs.ReadStream) {
+                const chunks = [];
+                try {
+                    for (_b = true, file_1 = __asyncValues(file); file_1_1 = yield file_1.next(), _c = file_1_1.done, !_c; _b = true) {
+                        _e = file_1_1.value;
+                        _b = false;
+                        const chunk = _e;
+                        chunks.push(Buffer.from(chunk));
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_b && !_c && (_d = file_1.return)) yield _d.call(file_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                contents = Buffer.concat(chunks).toString("base64");
+            }
+            else if (file instanceof Blob) {
+                const toBase64 = (file) => new Promise((res) => {
+                    const reader = new FileReader();
+                    reader.readAsDataURL(file);
+                    reader.onload = () => res(reader.result);
+                });
+                contents = yield toBase64(file);
+            }
+            else {
+                throw new errors.HumeError({
+                    message: `file must be one of ReadStream or Blob.`,
+                });
+            }
+            const request = {
+                payloadId: (0, uuid_1.v4)(),
+                data: contents,
+                models: this.config,
+                rawText: false,
+            };
+            if (this.streamWindowMs != null) {
+                request.streamWindowMs = this.streamWindowMs;
+            }
+            const response = yield this.send(request);
+            if (response == null) {
+                throw new errors.HumeError({
+                    message: `Received no response after sending file: ${file}`,
+                });
+            }
+            return response;
+        });
+    }
+    /**
+     * Send text on the `StreamSocket`
+     *
+     * @param text Text to send to the language model.
+     * @param config This method is intended for use with a `LanguageConfig`.
+     * When the socket is configured for other modalities this method will fail.
+     */
+    sendText(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ text, config, }) {
+            if (config != null) {
+                this.config = config;
+            }
+            const request = {
+                payloadId: (0, uuid_1.v4)(),
+                data: text,
+                rawText: true,
+                models: this.config,
+            };
+            if (this.streamWindowMs != null) {
+                request.streamWindowMs = this.streamWindowMs;
+            }
+            const response = yield this.send(request);
+            if (response == null) {
+                throw new errors.HumeError({
+                    message: `Received no response after sending text: ${text}`,
+                });
+            }
+            return response;
+        });
+    }
+    /**
+     * Send facemesh landmarks on the `StreamSocket`
+     *
+     * @param landmarks List of landmark points for multiple faces.
+     * The shape of this 3-dimensional list should be (n, 478, 3) where n is the number
+     * of faces to be processed, 478 is the number of MediaPipe landmarks per face and 3
+     * represents the (x, y, z) coordinates of each landmark.
+     * @param config List of model configurations.
+     * If set these configurations will overwrite existing configurations
+     */
+    sendFacemesh(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ landmarks, config, }) {
+            const response = this.sendText({
+                text: (0, base64Encode_1.base64Encode)(JSON.stringify(landmarks)),
+                config,
+            });
+            return response;
+        });
+    }
+    /**
+     *
+     * Reset the streaming sliding window.
+     *
+     * Call this method when some media has been fully processed and you want to continue using the same
+     * streaming connection without leaking context across media samples.
+     */
+    reset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send({
+                resetStream: true,
+            });
+        });
+    }
+    /**
+     *
+     * Get details associated with the current streaming connection.
+     *
+     */
+    getJobDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send({
+                jobDetails: true,
+            });
+        });
+    }
+    /**
+     * Closes the underlying socket.
+     */
+    close() {
+        this.websocket.close();
+    }
+    send(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.tillSocketOpen();
+            const jsonPayload = serializers.expressionMeasurement.stream.StreamModelsEndpointPayload.jsonOrThrow(payload, {
+                unrecognizedObjectKeys: "strip",
+            });
+            this.websocket.send(JSON.stringify(jsonPayload));
+            const response = yield new Promise((resolve) => {
+                this.websocket.addEventListener("message", (event) => {
+                    const response = (0, StreamingClient_1.parse)(event.data);
+                    resolve(response);
+                });
+            });
+            if (response != null && isError(response)) {
+                throw new errors.HumeError({
+                    message: `CODE ${response.code}: ${response.error}`,
+                });
+            }
+            return response;
+        });
+    }
+    tillSocketOpen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.websocket.readyState === ws_1.default.OPEN) {
+                return this.websocket;
+            }
+            return new Promise((resolve, reject) => {
+                this.websocket.addEventListener("open", () => {
+                    resolve(this.websocket);
+                });
+                this.websocket.addEventListener("error", (event) => {
+                    reject(event);
+                });
+            });
+        });
+    }
+}
+exports.StreamSocket = StreamSocket;
+function isError(response) {
+    return response.error != null;
+}

package/dist/wrapper/expressionMeasurement/streaming/StreamingClient.d.ts

@@ -0,0 +1,26 @@
+import * as Hume from "../../../api";
+import * as core from "../../../core";
+import { StreamSocket } from "./StreamSocket";
+import WebSocket from "ws";
+export declare namespace StreamClient {
+    interface Options {
+        apiKey?: core.Supplier<string | undefined>;
+    }
+    interface ConnectArgs {
+        config: Hume.expressionMeasurement.stream.Config;
+        streamWindowMs?: number;
+        onOpen?: (event: WebSocket.Event) => void;
+        onMessage?: (message: Hume.expressionMeasurement.stream.Config) => void;
+        onError?: (error: Hume.expressionMeasurement.stream.StreamErrorMessage) => void;
+        onClose?: (event: WebSocket.Event) => void;
+    }
+}
+export declare class StreamClient {
+    protected readonly _options: StreamClient.Options;
+    constructor(_options: StreamClient.Options);
+    connect(args: StreamClient.ConnectArgs): StreamSocket;
+}
+export declare function parse(data: WebSocket.Data, args?: {
+    onMessage?: (message: Hume.expressionMeasurement.stream.Config) => void;
+    onError?: (error: Hume.expressionMeasurement.stream.StreamErrorMessage) => void;
+}): Hume.expressionMeasurement.stream.Config | Hume.expressionMeasurement.stream.StreamErrorMessage | undefined;