@jupyterlite/pyodide-kernel 0.4.0-alpha.2 → 0.4.0-rc.0

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export * from './_pypi';
+export * from './coincident.worker';
 export * from './comlink.worker';
 export * from './kernel';
 export * from './tokens';

package/lib/index.js

@@ -1,6 +1,7 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
 export * from './_pypi';
+export * from './coincident.worker';
 export * from './comlink.worker';
 export * from './kernel';
 export * from './tokens';

package/lib/kernel.d.ts

@@ -1,4 +1,4 @@
-import { KernelMessage } from '@jupyterlab/services';
+import { Contents, KernelMessage } from '@jupyterlab/services';
 import { BaseKernel, IKernel } from '@jupyterlite/kernel';
 import { IPyodideWorkerKernel } from './tokens';
 /**
@@ -20,7 +20,14 @@ export declare class PyodideKernel extends BaseKernel implements IKernel {
      * webpack to find it.
      */
     protected initWorker(options: PyodideKernel.IOptions): Worker;
-    protected initRemote(options: PyodideKernel.IOptions): Promise<void>;
+    /**
+     * Initialize the remote kernel.
+     * Use coincident if crossOriginIsolated, comlink otherwise
+     * See the two following issues for more context:
+     *  - https://github.com/jupyterlite/jupyterlite/issues/1424
+     *  - https://github.com/jupyterlite/pyodide-kernel/pull/126
+     */
+    protected initRemote(options: PyodideKernel.IOptions): IPyodideWorkerKernel;
     protected initRemoteOptions(options: PyodideKernel.IOptions): IPyodideWorkerKernel.IOptions;
     /**
      * Dispose the kernel.
@@ -100,6 +107,8 @@ export declare class PyodideKernel extends BaseKernel implements IKernel {
      * @param content - The content of the reply.
      */
     inputReply(content: KernelMessage.IInputReplyMsg['content']): Promise<void>;
+    private _contentsManager;
+    private _contentsProcessor;
     private _worker;
     private _remoteKernel;
     private _ready;
@@ -140,5 +149,9 @@ export declare namespace PyodideKernel {
             lockFileURL: string;
             packages: string[];
         };
+        /**
+         * The Jupyterlite content manager
+         */
+        contentsManager: Contents.IManager;
     }
 }

package/lib/kernel.js

@@ -1,8 +1,10 @@
+import coincident from 'coincident';
+import { proxy, wrap } from 'comlink';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { PageConfig } from '@jupyterlab/coreutils';
 import { BaseKernel } from '@jupyterlite/kernel';
-import { wrap } from 'comlink';
 import { allJSONUrl, pipliteWheelUrl } from './_pypi';
+import { DriveContentsProcessor, } from '@jupyterlite/contents';
 /**
  * A kernel that executes Python code with Pyodide.
  */
@@ -16,9 +18,8 @@ export class PyodideKernel extends BaseKernel {
         super(options);
         this._ready = new PromiseDelegate();
         this._worker = this.initWorker(options);
-        this._worker.onmessage = (e) => this._processWorkerMessage(e.data);
-        this._remoteKernel = wrap(this._worker);
-        this.initRemote(options);
+        this._remoteKernel = this.initRemote(options);
+        this._contentsManager = options.contentsManager;
     }
     /**
      * Load the worker.
@@ -29,14 +30,49 @@ export class PyodideKernel extends BaseKernel {
      * webpack to find it.
      */
     initWorker(options) {
-        return new Worker(new URL('./comlink.worker.js', import.meta.url), {
-            type: 'module',
-        });
+        if (crossOriginIsolated) {
+            return new Worker(new URL('./coincident.worker.js', import.meta.url), {
+                type: 'module',
+            });
+        }
+        else {
+            return new Worker(new URL('./comlink.worker.js', import.meta.url), {
+                type: 'module',
+            });
+        }
     }
-    async initRemote(options) {
+    /**
+     * Initialize the remote kernel.
+     * Use coincident if crossOriginIsolated, comlink otherwise
+     * See the two following issues for more context:
+     *  - https://github.com/jupyterlite/jupyterlite/issues/1424
+     *  - https://github.com/jupyterlite/pyodide-kernel/pull/126
+     */
+    initRemote(options) {
+        let remote;
+        if (crossOriginIsolated) {
+            remote = coincident(this._worker);
+            remote.processWorkerMessage = this._processWorkerMessage.bind(this);
+            // The coincident worker uses its own filesystem API:
+            remote.processDriveRequest = async (data) => {
+                if (!DriveContentsProcessor) {
+                    throw new Error('File system calls over Atomics.wait is only supported with jupyterlite>=0.4.0a3');
+                }
+                if (this._contentsProcessor === undefined) {
+                    this._contentsProcessor = new DriveContentsProcessor({
+                        contentsManager: this._contentsManager,
+                    });
+                }
+                return await this._contentsProcessor.processDriveRequest(data);
+            };
+        }
+        else {
+            remote = wrap(this._worker);
+            remote.registerCallback(proxy(this._processWorkerMessage.bind(this)));
+        }
         const remoteOptions = this.initRemoteOptions(options);
-        await this._remoteKernel.initialize(remoteOptions);
-        this._ready.resolve();
+        remote.initialize(remoteOptions).then(this._ready.resolve.bind(this._ready));
+        return remote;
     }
     initRemoteOptions(options) {
         const { pyodideUrl } = options;

package/lib/tokens.d.ts

@@ -1,7 +1,7 @@
 /**
  * Definitions for the Pyodide kernel.
  */
-import type { Remote } from 'comlink';
+import { TDriveMethod, TDriveRequest, TDriveResponse } from '@jupyterlite/contents';
 import { IWorkerKernel } from '@jupyterlite/kernel';
 /**
  * The schema for a Warehouse-like index, as used by piplite.
@@ -15,11 +15,25 @@ export interface IPyodideWorkerKernel extends IWorkerKernel {
      * Handle any lazy initialization activities.
      */
     initialize(options: IPyodideWorkerKernel.IOptions): Promise<void>;
+    /**
+     * Process drive request
+     * @param data
+     */
+    processDriveRequest<T extends TDriveMethod>(data: TDriveRequest<T>): TDriveResponse<T>;
+    /**
+     * Process worker message
+     * @param msg
+     */
+    processWorkerMessage(msg: any): void;
+    /**
+     * Register a callback for handling messages from the worker.
+     */
+    registerCallback(callback: (msg: any) => void): void;
 }
 /**
- * An convenience interface for Pyodide workers wrapped by a comlink Remote.
+ * Deprecated.
  */
-export type IRemotePyodideWorkerKernel = Remote<IPyodideWorkerKernel>;
+export type IRemotePyodideWorkerKernel = IPyodideWorkerKernel;
 /**
  * An namespace for Pyodide workers.
  */

package/lib/worker.d.ts

@@ -1,5 +1,6 @@
 import type Pyodide from 'pyodide';
 import type { DriveFS } from '@jupyterlite/contents';
+import { KernelMessage } from '@jupyterlab/services';
 import type { IPyodideWorkerKernel } from './tokens';
 export declare class PyodideRemoteKernel {
     constructor();
@@ -26,6 +27,11 @@ export declare class PyodideRemoteKernel {
      * @param res The result object from the Pyodide evaluation
      */
     formatResult(res: any): any;
+    /**
+     * Register the callback function to send messages from the worker back to the main thread.
+     * @param callback the callback to register
+     */
+    registerCallback(callback: (msg: any) => void): void;
     /**
      * Makes sure pyodide is ready before continuing, and cache the parent message.
      */
@@ -65,10 +71,7 @@ export declare class PyodideRemoteKernel {
      *
      * @param content The incoming message with the comm target name.
      */
-    commInfo(content: any, parent: any): Promise<{
-        comms: any;
-        status: string;
-    }>;
+    commInfo(content: any, parent: any): Promise<KernelMessage.ICommInfoReplyMsg['content']>;
     /**
      * Respond to the commOpen.
      *
@@ -131,4 +134,5 @@ export declare class PyodideRemoteKernel {
     protected _stderr_stream: any;
     protected _resolveInputReply: any;
     protected _driveFS: DriveFS | null;
+    protected _sendWorkerMessage: (msg: any) => void;
 }