@coherentglobal/wasm-runner 0.0.103 → 0.1.19

package/dist/node/threads/workerThread.js

@@ -0,0 +1,91 @@
+"use strict";
+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 });
+const worker_threads_1 = require("worker_threads");
+const poolifier_1 = require("poolifier");
+const constants_1 = require("../../constants");
+const activeListeners = new Map();
+class WorkerThread extends poolifier_1.ThreadWorker {
+    constructor(taskFunctions, opts) {
+        super(taskFunctions, opts);
+        this.cleanupListener = (eventId) => {
+            setTimeout(() => {
+                const listener = activeListeners.get(eventId);
+                if (listener) {
+                    worker_threads_1.parentPort.off("message", listener);
+                    activeListeners.delete(eventId);
+                }
+            });
+        };
+    }
+    /**
+     * Sends message back to the main thread.
+     *
+     * @param {EventRequestData} message
+     */
+    postMessage(message) {
+        if (worker_threads_1.isMainThread) {
+            throw Error("Failed to post message using main thread.");
+        }
+        else {
+            worker_threads_1.parentPort.postMessage(message);
+        }
+    }
+    /**
+     * Receives message from the main thread or other threads.
+     *
+     * @param {Function} callback
+     * Function to receive the message data.
+     */
+    onMessage(callback) {
+        if (worker_threads_1.isMainThread) {
+            throw Error("Failed to receive message using main thread.");
+        }
+        else {
+            worker_threads_1.parentPort.on("message", callback);
+        }
+    }
+    /**
+     * Sends a request to the main thread and waits for a response.
+     *
+     * @param {Object} payload
+     * Object or details that needs to be passed to main thread as `payload`.
+     *
+     * @returns {Promise<Object>}
+     * Response from main thread.
+     */
+    requestMessage(payload, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                // Send the request to parent
+                this.postMessage({
+                    payload,
+                    context,
+                    type: constants_1.THREAD_EVENT_TYPES.REQUEST_EXECUTE,
+                    threadId: worker_threads_1.threadId,
+                });
+                // Receive the response from parent once ready
+                const messageListener = (message) => {
+                    worker_threads_1.parentPort.off("message", messageListener);
+                    if ((message === null || message === void 0 ? void 0 : message.type) === constants_1.THREAD_EVENT_TYPES.RESPONSE) {
+                        resolve(message === null || message === void 0 ? void 0 : message.payload);
+                    }
+                    else if ((message === null || message === void 0 ? void 0 : message.type) === constants_1.THREAD_EVENT_TYPES.ERROR) {
+                        reject(message === null || message === void 0 ? void 0 : message.payload);
+                    }
+                };
+                this.onMessage(messageListener);
+            });
+        });
+    }
+}
+exports.default = WorkerThread;
+//# sourceMappingURL=workerThread.js.map

package/dist/node/threads/workerThread.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerThread.js","sourceRoot":"","sources":["../../../src/node/threads/workerThread.ts"],"names":[],"mappings":";;;;;;;;;;;AAAA,mDAAoE;AAEpE,yCAAyC;AACzC,+CAAqD;AAKrD,MAAM,eAAe,GAAG,IAAI,GAAG,EAAE,CAAC;AAElC,MAAM,YAAa,SAAQ,wBAAY;IACrC,YACE,aAEoC,EACpC,IAAoB;QAEpB,KAAK,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;QA8BrB,oBAAe,GAAG,CAAC,OAAO,EAAE,EAAE;YACpC,UAAU,CAAC,GAAG,EAAE;gBACd,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAC9C,IAAI,QAAQ,EAAE,CAAC;oBACb,2BAAU,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;oBACpC,eAAe,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;gBAClC,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;IArCF,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,OAAyB;QACnC,IAAI,6BAAY,EAAE,CAAC;YACjB,MAAM,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC3D,CAAC;aAAM,CAAC;YACN,2BAAU,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,QAA+B;QACvC,IAAI,6BAAY,EAAE,CAAC;YACjB,MAAM,KAAK,CAAC,8CAA8C,CAAC,CAAC;QAC9D,CAAC;aAAM,CAAC;YACN,2BAAU,CAAC,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;IAYD;;;;;;;;OAQG;IACG,cAAc,CAAC,OAAY,EAAE,OAAY;;YAC7C,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACrC,6BAA6B;gBAC7B,IAAI,CAAC,WAAW,CAAC;oBACf,OAAO;oBACP,OAAO;oBACP,IAAI,EAAE,8BAAkB,CAAC,eAA6B;oBACtD,QAAQ,EAAR,yBAAQ;iBACT,CAAC,CAAC;gBAEH,8CAA8C;gBAC9C,MAAM,eAAe,GAAG,CAAC,OAAyB,EAAE,EAAE;oBACpD,2BAAU,CAAC,GAAG,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;oBAC3C,IAAI,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,MAAK,8BAAkB,CAAC,QAAQ,EAAE,CAAC;wBAClD,OAAO,CAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,OAAO,CAAC,CAAC;oBAC5B,CAAC;yBAAM,IAAI,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,MAAK,8BAAkB,CAAC,KAAK,EAAE,CAAC;wBACtD,MAAM,CAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,OAAO,CAAC,CAAC;oBAC3B,CAAC;gBAEH,CAAC,CAAC;gBACF,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;YAClC,CAAC,CAAC,CAAC;QACL,CAAC;KAAA;CACF;AAED,kBAAe,YAAY,CAAC"}

package/dist/node/threads/workerThread.ts

@@ -0,0 +1,92 @@
+import { isMainThread, parentPort, threadId } from "worker_threads";
+import { createId as cuid } from "@paralleldrive/cuid2";
+import { ThreadWorker } from "poolifier";
+import { THREAD_EVENT_TYPES } from "../../constants";
+
+import type { TaskFunctions, TaskFunction, WorkerOptions } from "poolifier";
+import type { EVENT_TYPE, EventRequestData } from "../../types";
+
+const activeListeners = new Map();
+
+class WorkerThread extends ThreadWorker {
+  constructor(
+    taskFunctions:
+      | TaskFunction<unknown, Response>
+      | TaskFunctions<unknown, Response>,
+    opts?: WorkerOptions
+  ) {
+    super(taskFunctions, opts);
+  }
+
+  /**
+   * Sends message back to the main thread.
+   *
+   * @param {EventRequestData} message
+   */
+  postMessage(message: EventRequestData) {
+    if (isMainThread) {
+      throw Error("Failed to post message using main thread.");
+    } else {
+      parentPort.postMessage(message);
+    }
+  }
+
+  /**
+   * Receives message from the main thread or other threads.
+   *
+   * @param {Function} callback
+   * Function to receive the message data.
+   */
+  onMessage(callback: (value?: any) => void) {
+    if (isMainThread) {
+      throw Error("Failed to receive message using main thread.");
+    } else {
+      parentPort.on("message", callback);
+    }
+  }
+
+  private cleanupListener = (eventId) => {
+    setTimeout(() => {
+      const listener = activeListeners.get(eventId);
+      if (listener) {
+        parentPort.off("message", listener);
+        activeListeners.delete(eventId);
+      }
+    });
+  };
+
+  /**
+   * Sends a request to the main thread and waits for a response.
+   *
+   * @param {Object} payload
+   * Object or details that needs to be passed to main thread as `payload`.
+   *
+   * @returns {Promise<Object>}
+   * Response from main thread.
+   */
+  async requestMessage(payload: any, context: any) {
+    return new Promise((resolve, reject) => {
+      // Send the request to parent
+      this.postMessage({
+        payload,
+        context,
+        type: THREAD_EVENT_TYPES.REQUEST_EXECUTE as EVENT_TYPE,
+        threadId,
+      });
+
+      // Receive the response from parent once ready
+      const messageListener = (message: EventRequestData) => {
+        parentPort.off("message", messageListener);
+        if (message?.type === THREAD_EVENT_TYPES.RESPONSE) {
+          resolve(message?.payload);
+        } else if (message?.type === THREAD_EVENT_TYPES.ERROR) {
+          reject(message?.payload);
+        }
+
+      };
+      this.onMessage(messageListener);
+    });
+  }
+}
+
+export default WorkerThread;

package/dist/node.d.ts

@@ -1,22 +1,9 @@
 import tmp from "tmp";
-import { StaticPool } from "node-worker-threads-pool";
-import { NodeModel, RunnerConfig, ModelConfig, ResponseObject } from "./types";
-import { CancellationToken } from './CancellationToken';
+import { NodeModel, RunnerConfig, ModelConfig, ResponseObject, Compatibility, WasmOptions, ModelInstance } from "./types";
+import { CancellationToken } from "./CancellationToken";
 export { ColumnarSerializer } from "./serializer/columnarSerializer";
-export { CancellationToken } from './CancellationToken';
+export { CancellationToken } from "./CancellationToken";
 export { ModelExecuteCancelled } from "./error";
-/**
- * WASM runner config
- * @typedef {Object} RunnerConfig
- * @property {string} id - Model id or version_uuid
- * @property {string} url - Model url
- */
-/**
- * Input object
- * @typedef {Object} InputObject
- * @property {Object} request_data - Request input date
- * @property {Object} request_meta - Request input meta
- */
 /**
  * WasmRunner class, responsible for managing model and it's lifecycle
  *
@@ -28,13 +15,16 @@ export declare class WasmRunner {
     _tempModelFolder: tmp.DirResult;
     license: string;
     models: any[];
-    externalResolverModule: string;
+    externalResolverModule: any;
+    initializingModels: string[];
+    options: WasmOptions;
+    safeCompiler: string;
     /**
      * Create new Wasm Runner instance
      *
      * @param {RunnerConfig} wasmRunnerConfig
      */
-    constructor(wasmRunnerConfig?: RunnerConfig, externalResolverModule?: string, license?: string);
+    constructor(wasmRunnerConfig?: RunnerConfig, externalResolverModule?: string, options?: any, license?: string);
     /**
      * Initialize wasm runner fetching model from remote server
      *
@@ -42,29 +32,46 @@ export declare class WasmRunner {
      * @function initialize
      */
     initialize(license?: string): Promise<void>;
-    _createModelInstance(id: any, url: any, workerFolder: any, size: any): Promise<StaticPool<any, any>>;
+    _createModelInstance(id: any, url: any, workerFolder: any, size?: number): Promise<ModelInstance>;
     _initializeModelInstance(m: NodeModel): Promise<void>;
-    _createModelInstanceFromURL(id: string, url: string, workerFolder: string, modelFolder: string, size: number): Promise<StaticPool<any, any>>;
+    _createModelInstanceFromURL(id: string, url: string, workerFolder: string, modelFolder: string, size: number): Promise<ModelInstance>;
     /**
-     * Append and initialized new model to runner
+     * Append and initialize model in preparation for the `execute()`.
+     *
      * @param {ModelConfig} modelConfig
-     * @returns Promise
+     * Model details like version_id as `id` and zip path as `url`.
+     *
+     * @returns {Promise<void>}
      */
     append(modelConfig: ModelConfig): Promise<void>;
     /**
-     * Remove model from runner
-     * @param {string} id Model id
-     * @returns Promise
+     * Remove model from the list of initialized model useful for GC.
+     *
+     * @param {String} id
+     * ID of the model that needs to be removed.
+     *
+     * @returns {Promise<void>}
      */
     remove(id: string): Promise<void>;
     _parseError(rawResponse: any): Object;
     _getModel(id: string): NodeModel;
+    getModelSize(id: string): number;
+    getModelCompilerVersion(id: any): string;
     /**
      * Check if model existed
      * @param {string} id Model id
-     * @returns boolean
+     * @returns {boolean}
      */
     isExist(id: string): boolean;
+    isModelCompatible(model: any, input: any): boolean;
+    getModelsStats(): {
+        stats: any;
+        busy: any;
+        size: any;
+        id: any;
+    }[];
+    private getPartiallyCompatibleMessage;
+    private getIncompatibleMessage;
     /**
      * Perform calculation. The runner will use request_meta.version_uuid of input argument to locate model
      * @async
@@ -72,4 +79,7 @@ export declare class WasmRunner {
      * @returns {Promise<ResponseObject>} - Response model data
      */
     execute(input: any, id?: string, raw?: boolean, cancelToken?: CancellationToken): Promise<ResponseObject>;
+    getNeuronCompilerVersion(logFile: any): Promise<any>;
+    checkCompilerVersionCompatibility(modelCompilerVersion: string): Promise<Compatibility>;
+    getSafeCompilerVersion(runnerVersion: string): any;
 }