hypha-rpc 0.20.48 → 0.20.50

package/dist/hypha-rpc-websocket.js

@@ -548,22 +548,24 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
 
   async get_manager_service(config) {
     config = config || {};
-    
+
     // Add retry logic
     const maxRetries = 20;
     const retryDelay = 500; // 500ms
-    
+
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       if (!this._connection.manager_id) {
         if (attempt < maxRetries - 1) {
-          console.warn(`Manager ID not set, retrying in ${retryDelay}ms (attempt ${attempt+1}/${maxRetries})`);
-          await new Promise(resolve => setTimeout(resolve, retryDelay));
+          console.warn(
+            `Manager ID not set, retrying in ${retryDelay}ms (attempt ${attempt + 1}/${maxRetries})`,
+          );
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
           continue;
         } else {
           throw new Error("Manager ID not set after maximum retries");
         }
       }
-      
+
       try {
         const svc = await this.get_remote_service(
           `*/${this._connection.manager_id}:default`,
@@ -572,8 +574,10 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         return svc;
       } catch (e) {
         if (attempt < maxRetries - 1) {
-          console.warn(`Failed to get manager service, retrying in ${retryDelay}ms: ${e.message}`);
-          await new Promise(resolve => setTimeout(resolve, retryDelay));
+          console.warn(
+            `Failed to get manager service, retrying in ${retryDelay}ms: ${e.message}`,
+          );
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
         } else {
           throw e;
         }
@@ -1519,7 +1523,59 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       return bObject;
     }
 
-    if (typeof aObject === "function") {
+    if ((0,_utils__WEBPACK_IMPORTED_MODULE_0__.isGenerator)(aObject) || (0,_utils__WEBPACK_IMPORTED_MODULE_0__.isAsyncGenerator)(aObject)) {
+      // Handle generator functions and generator objects
+      (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+        session_id && typeof session_id === "string",
+        "Session ID is required for generator encoding",
+      );
+      const object_id = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.randId)();
+
+      // Get the session store
+      const store = this._get_session_store(session_id, true);
+      (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
+        store !== null,
+        `Failed to create session store ${session_id} due to invalid parent`,
+      );
+
+      // Check if it's an async generator
+      const isAsync = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.isAsyncGenerator)(aObject);
+
+      // Define method to get next item from the generator
+      const nextItemMethod = async () => {
+        if (isAsync) {
+          const iterator = aObject;
+          const result = await iterator.next();
+          if (result.done) {
+            delete store[object_id];
+            return { _rtype: "stop_iteration" };
+          }
+          return result.value;
+        } else {
+          const iterator = aObject;
+          const result = iterator.next();
+          if (result.done) {
+            delete store[object_id];
+            return { _rtype: "stop_iteration" };
+          }
+          return result.value;
+        }
+      };
+
+      // Store the next_item method in the session
+      store[object_id] = nextItemMethod;
+
+      // Create a method that will be used to fetch the next item from the generator
+      bObject = {
+        _rtype: "generator",
+        _rserver: this._server_base_url,
+        _rtarget: this._client_id,
+        _rmethod: `${session_id}.${object_id}`,
+        _rpromise: "*",
+        _rdoc: "Remote generator",
+      };
+      return bObject;
+    } else if (typeof aObject === "function") {
       if (this._method_annotations.has(aObject)) {
         let annotation = this._method_annotations.get(aObject);
         bObject = {
@@ -1765,6 +1821,38 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
           remote_workspace,
           local_workspace,
         );
+      } else if (aObject._rtype === "generator") {
+        // Create a method to fetch next items from the remote generator
+        const gen_method = this._generate_remote_method(
+          aObject,
+          remote_parent,
+          local_parent,
+          remote_workspace,
+          local_workspace,
+        );
+
+        // Create an async generator proxy
+        async function* asyncGeneratorProxy() {
+          try {
+            while (true) {
+              try {
+                const next_item = await gen_method();
+                // Check for StopIteration signal
+                if (next_item && next_item._rtype === "stop_iteration") {
+                  break;
+                }
+                yield next_item;
+              } catch (error) {
+                console.error("Error in generator:", error);
+                throw error;
+              }
+            }
+          } catch (error) {
+            console.error("Error in generator:", error);
+            throw error;
+          }
+        }
+        bObject = asyncGeneratorProxy();
       } else if (aObject._rtype === "ndarray") {
         /*global nj tf*/
         //create build array/tensor if used in the plugin
@@ -1935,6 +2023,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   convertCase: () => (/* binding */ convertCase),
 /* harmony export */   dtypeToTypedArray: () => (/* binding */ dtypeToTypedArray),
 /* harmony export */   expandKwargs: () => (/* binding */ expandKwargs),
+/* harmony export */   isAsyncGenerator: () => (/* binding */ isAsyncGenerator),
+/* harmony export */   isGenerator: () => (/* binding */ isGenerator),
 /* harmony export */   loadRequirements: () => (/* binding */ loadRequirements),
 /* harmony export */   loadRequirementsInWebworker: () => (/* binding */ loadRequirementsInWebworker),
 /* harmony export */   loadRequirementsInWindow: () => (/* binding */ loadRequirementsInWindow),
@@ -2456,6 +2546,40 @@ class Semaphore {
   }
 }
 
+/**
+ * Check if the object is a generator
+ * @param {Object} obj - Object to check
+ * @returns {boolean} - True if the object is a generator
+ */
+function isGenerator(obj) {
+  if (!obj) return false;
+
+  return (
+    typeof obj === "object" &&
+    typeof obj.next === "function" &&
+    typeof obj.throw === "function" &&
+    typeof obj.return === "function"
+  );
+}
+
+/**
+ * Check if an object is an async generator object
+ * @param {any} obj - Object to check
+ * @returns {boolean} True if object is an async generator object
+ */
+function isAsyncGenerator(obj) {
+  if (!obj) return false;
+  // Check if it's an async generator object
+  return (
+    typeof obj === "object" &&
+    typeof obj.next === "function" &&
+    typeof obj.throw === "function" &&
+    typeof obj.return === "function" &&
+    Symbol.asyncIterator in Object(obj) &&
+    obj[Symbol.toStringTag] === "AsyncGenerator"
+  );
+}
+
 
 /***/ }),
 
@@ -2522,7 +2646,13 @@ class WebRTCConnection {
     this._handle_disconnected = null;
     this._handle_connected = () => {};
     this.manager_id = null;
+    this._last_message = null;
     this._data_channel.onopen = async () => {
+      if (this._last_message) {
+        console.info("Resending last message after connection established");
+        this._data_channel.send(this._last_message);
+        this._last_message = null;
+      }
       this._handle_connected &&
         this._handle_connected({ channel: this._data_channel });
     };
@@ -2557,15 +2687,17 @@ class WebRTCConnection {
   async emit_message(data) {
     (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(this._handle_message, "No handler for message");
     try {
+      this._last_message = data;
       this._data_channel.send(data);
+      this._last_message = null;
     } catch (exp) {
-      //   data = msgpack_unpackb(data);
       console.error(`Failed to send data, error: ${exp}`);
       throw exp;
     }
   }
 
   async disconnect(reason) {
+    this._last_message = null;
     this._data_channel = null;
     console.info(`data channel connection disconnected (${reason})`);
   }
@@ -4800,6 +4932,7 @@ class WebsocketRPCConnection {
     this._token_refresh_interval = token_refresh_interval;
     this.manager_id = null;
     this._refresh_token_task = null;
+    this._last_message = null; // Store the last sent message
   }
 
   on_message(handler) {
@@ -5038,6 +5171,12 @@ class WebsocketRPCConnection {
               `Reconnecting to ${this._server_url.split("?")[0]} (attempt #${retry})`,
             );
             await this.open();
+            // Resend last message if there was one
+            if (this._last_message) {
+              console.info("Resending last message after reconnection");
+              this._websocket.send(this._last_message);
+              this._last_message = null;
+            }
             console.warn(
               `Successfully reconnected to server ${this._server_url}`,
             );
@@ -5083,7 +5222,9 @@ class WebsocketRPCConnection {
       await this.open();
     }
     try {
+      this._last_message = data; // Store the message before sending
       this._websocket.send(data);
+      this._last_message = null; // Clear after successful send
     } catch (exp) {
       console.error(`Failed to send data, error: ${exp}`);
       throw exp;
@@ -5092,6 +5233,7 @@ class WebsocketRPCConnection {
 
   disconnect(reason) {
     this._closed = true;
+    this._last_message = null; // Clear last message on disconnect
     if (this._websocket && this._websocket.readyState === WebSocket.OPEN) {
       this._websocket.close(1000, reason);
     }
@@ -5213,20 +5355,20 @@ async function connectToServer(config) {
     "Failed to connect to the server, no connection info obtained. This issue is most likely due to an outdated Hypha server version. Please use `imjoy-rpc` for compatibility, or upgrade the Hypha server to the latest version.",
   );
   // wait for 0.5 seconds
-  await new Promise(resolve => setTimeout(resolve, 100));
+  await new Promise((resolve) => setTimeout(resolve, 100));
   // Ensure manager_id is set before proceeding
   if (!connection.manager_id) {
     console.warn("Manager ID not set immediately, waiting...");
-    
+
     // Wait for manager_id to be set with timeout
     const maxWaitTime = 5000; // 5 seconds
     const checkInterval = 100; // 100ms
     const startTime = Date.now();
-    
-    while (!connection.manager_id && (Date.now() - startTime) < maxWaitTime) {
-      await new Promise(resolve => setTimeout(resolve, checkInterval));
+
+    while (!connection.manager_id && Date.now() - startTime < maxWaitTime) {
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
     }
-    
+
     if (!connection.manager_id) {
       console.error("Manager ID still not set after waiting");
       throw new Error("Failed to get manager ID from server");
@@ -5239,7 +5381,7 @@ async function connectToServer(config) {
       `Connected to the wrong workspace: ${connection_info.workspace}, expected: ${config.workspace}`,
     );
   }
-  
+
   const workspace = connection_info.workspace;
   const rpc = new _rpc_js__WEBPACK_IMPORTED_MODULE_0__.RPC(connection, {
     client_id: clientId,