hume 0.3.3 → 0.4.1

package/wrapper/StreamSocket.js

@@ -1,4 +1,27 @@
 "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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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) {
@@ -8,9 +31,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 promises_1 = require("fs/promises");
+const ws_1 = __importDefault(require("ws"));
+const uuid_1 = require("uuid");
+const HumeStreamingClient_1 = require("./HumeStreamingClient");
+const base64Encode_1 = require("./base64Encode");
+const serializers = __importStar(require("../serialization"));
+const errors = __importStar(require("../errors"));
+const fs = __importStar(require("fs"));
 class StreamSocket {
     constructor({ websocket, config, streamWindowMs }) {
         this.websocket = websocket;
@@ -18,33 +57,62 @@ class StreamSocket {
         this.streamWindowMs = streamWindowMs;
     }
     /**
-     * Send a file on the `StreamSocket`
+     * Send file on the `StreamSocket`
      *
-     * @param filepath Path to media file to send on socket connection
-     * @param config List of model configurations.
-     * If set these configurations will overwrite any configurations
-     * set when initializing 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({ filepath, config, }) {
+    sendFile({ file, config, }) {
+        var file_1, file_1_1;
+        var e_1, _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.sendBuffer({
-                buffer: yield (0, promises_1.readFile)(filepath),
-                config,
-            });
-        });
-    }
-    /**
-     * Send raw bytes on the `StreamSocket`
-     *
-     * @param buffer Raw bytes of media to send on socket connection
-     * @param config List of model configurations.
-     * If set these configurations will overwrite any configurations
-     * set when initializing the `StreamSocket`
-     */
-    sendBuffer({ buffer, config, }) {
-        this.sendText({
-            text: buffer.toString("base64"),
-            config,
+            if (config != null) {
+                this.config = config;
+            }
+            let contents = "";
+            if (file instanceof fs.ReadStream) {
+                const chunks = [];
+                try {
+                    for (file_1 = __asyncValues(file); file_1_1 = yield file_1.next(), !file_1_1.done;) {
+                        const chunk = file_1_1.value;
+                        chunks.push(Buffer.from(chunk));
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (file_1_1 && !file_1_1.done && (_a = file_1.return)) yield _a.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, err) => {
+                    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;
         });
     }
     /**
@@ -54,16 +122,26 @@ class StreamSocket {
      * @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, }) {
-        if (config != null) {
-            this.config = config;
-        }
-        this.websocket.send(JSON.stringify({
-            data: text,
-            raw_text: true,
-            models: this.config,
-            stream_window_ms: this.streamWindowMs,
-        }));
+    sendText({ text, config }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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`
@@ -76,10 +154,12 @@ class StreamSocket {
      * If set these configurations will overwrite existing configurations
      */
     sendFacemesh({ landmarks, config, }) {
-        const stringifiedLandmarks = JSON.stringify(landmarks);
-        this.sendText({
-            text: Buffer.from(stringifiedLandmarks).toString("base64"),
-            config,
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = this.sendText({
+                text: (0, base64Encode_1.base64Encode)(JSON.stringify(landmarks)),
+                config,
+            });
+            return response;
         });
     }
     /**
@@ -90,9 +170,11 @@ class StreamSocket {
      * streaming connection without leaking context across media samples.
      */
     reset() {
-        this.websocket.send(JSON.stringify({
-            reset_stream: true,
-        }));
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send({
+                resetStream: true,
+            });
+        });
     }
     /**
      *
@@ -100,9 +182,11 @@ class StreamSocket {
      *
      */
     getJobDetails() {
-        this.websocket.send(JSON.stringify({
-            job_details: true,
-        }));
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.send({
+                jobDetails: true,
+            });
+        });
     }
     /**
      * Closes the underlying socket.
@@ -110,5 +194,48 @@ class StreamSocket {
     close() {
         this.websocket.close();
     }
+    send(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.tillSocketOpen();
+            const jsonPayload = yield serializers.ModelsInput.jsonOrThrow(payload, {
+                unrecognizedObjectKeys: "strip",
+            });
+            this.websocket.send(JSON.stringify(jsonPayload));
+            const response = yield new Promise((resolve, reject) => {
+                this.websocket.addEventListener("message", (event) => {
+                    const response = (0, HumeStreamingClient_1.parse)(event.data);
+                    resolve(response);
+                });
+            });
+            if (response != null && isError(response)) {
+                throw new errors.HumeError({ message: `CODE ${response.code}: ${response.error}` });
+            }
+            if (response != null && isWarning(response)) {
+                throw new errors.HumeError({ message: `CODE ${response.code}: ${response.warning}` });
+            }
+            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;
+}
+function isWarning(response) {
+    return response.warning != null;
+}

package/wrapper/base64Encode.d.ts

@@ -0,0 +1 @@
+export declare function base64Encode(str: string): string;

package/wrapper/base64Encode.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Encode = void 0;
+function base64Encode(str) {
+    if (typeof Buffer === "function") {
+        // Node.js environment
+        return Buffer.from(str).toString("base64");
+    }
+    else if (typeof btoa === "function") {
+        // Browser environment
+        return btoa(str);
+    }
+    else {
+        throw new Error("Base64 encoding not supported in this environment.");
+    }
+}
+exports.base64Encode = base64Encode;