@cfasim-ui/pyodide 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfasim-ui/pyodide",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "description": "Pyodide (Python-in-browser) integration for cfasim-ui",
   "license": "Apache-2.0",
@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "pyodide": "^0.29.3",
-    "@cfasim-ui/shared": "0.1.7"
+    "@cfasim-ui/shared": "0.1.9"
   },
   "peerDependencies": {
     "vue": "^3.5.0"

package/src/pyodide.worker.ts

@@ -14,7 +14,6 @@ interface WorkerMessage {
 }
 
 let wheelMap: Record<string, string> = {};
-const loadedModules = new Set<string>();
 
 const baseUrl = import.meta.env.BASE_URL ?? "/";
 
@@ -44,28 +43,43 @@ const pyodideReadyPromise = (async () => {
   return pyodide;
 })();
 
-let wheelsInstalled = false;
+let installPromise: Promise<void> | null = null;
 
-async function installAllWheels() {
-  if (wheelsInstalled) return;
-  wheelsInstalled = true;
-  const urls = Object.values(wheelMap).map(
-    (f) => `${self.location.origin}${baseUrl}${f}`,
-  );
-  if (urls.length > 0) {
-    await micropip.install(urls);
+function installAllWheels(): Promise<void> {
+  if (!installPromise) {
+    installPromise = (async () => {
+      const urls = Object.values(wheelMap).map(
+        (f) => `${self.location.origin}${baseUrl}${f}`,
+      );
+      if (urls.length > 0) {
+        await micropip.install(urls);
+      }
+    })();
+    installPromise.catch(() => {
+      installPromise = null;
+    });
   }
+  return installPromise;
 }
 
-async function ensureModule(
+const modulePromises = new Map<string, Promise<void>>();
+
+function ensureModule(
   pyodide: Awaited<typeof pyodideReadyPromise>,
   moduleName: string,
-) {
-  if (loadedModules.has(moduleName)) return;
-  if (!wheelMap[moduleName]) throw new Error(`Unknown module: ${moduleName}`);
-  await installAllWheels();
-  pyodide.pyimport(moduleName);
-  loadedModules.add(moduleName);
+): Promise<void> {
+  if (!modulePromises.has(moduleName)) {
+    if (!wheelMap[moduleName]) throw new Error(`Unknown module: ${moduleName}`);
+    const promise = (async () => {
+      await installAllWheels();
+      pyodide.pyimport(moduleName);
+    })();
+    promise.catch(() => {
+      modulePromises.delete(moduleName);
+    });
+    modulePromises.set(moduleName, promise);
+  }
+  return modulePromises.get(moduleName)!;
 }
 
 // Map Python struct format characters to TypedArray constructors
@@ -122,6 +136,13 @@ function convertModelOutputs(jsResult: any): ModelOutputsWire | null {
         if ((buf as any).destroy) (buf as any).destroy();
       } else if (buf instanceof ArrayBuffer) {
         buffers.push(buf);
+      } else if (ArrayBuffer.isView(buf)) {
+        buffers.push(
+          buf.buffer.slice(
+            buf.byteOffset,
+            buf.byteOffset + buf.byteLength,
+          ) as ArrayBuffer,
+        );
       }
     }
 

package/src/useModel.ts

@@ -1,4 +1,4 @@
-import { ref, toValue, watch } from "vue";
+import { ref, toRaw, toValue, watch } from "vue";
 import type { MaybeRef } from "vue";
 import type { ModelOutput } from "@cfasim-ui/shared";
 import { asyncRunPython, loadModule } from "./pyodideWorkerApi.js";
@@ -20,9 +20,14 @@ export function useModel<T = unknown>(moduleName: string) {
       await loaded;
       const argNames = context ? Object.keys(context) : [];
       const callArgs = argNames.join(", ");
+      const plainContext = context
+        ? Object.fromEntries(
+            Object.entries(context).map(([k, v]) => [k, toRaw(v)]),
+          )
+        : undefined;
       const response = await asyncRunPython(
         `import ${moduleName}\n${moduleName}.${fn}(${callArgs})`,
-        context,
+        plainContext,
       );
       if (response.error) {
         error.value = response.error;
@@ -51,11 +56,14 @@ export function useModel<T = unknown>(moduleName: string) {
         outputsError.value = undefined;
         try {
           await loaded;
-          const argNames = Object.keys(p);
+          const plain = Object.fromEntries(
+            Object.entries(p).map(([k, v]) => [k, toRaw(v)]),
+          );
+          const argNames = Object.keys(plain);
           const callArgs = argNames.join(", ");
           const response = await asyncRunPython(
             `import ${moduleName}\n${moduleName}.${fn}(${callArgs})`,
-            p,
+            plain,
           );
           if (response.error) {
             outputsError.value = response.error;