jupyterpack 0.2.1 → 0.4.0

package/lib/pythonServer/tornado/tornadoServer.js

@@ -0,0 +1,68 @@
+import { stringOrNone } from '../../tools';
+import { JupyterPackFramework } from '../../type';
+import { KernelExecutor } from '../kernelExecutor';
+export class TornadoServer extends KernelExecutor {
+    constructor() {
+        super(...arguments);
+        this._SERVER_VAR = '__jupyterpack_tornado_server';
+    }
+    async init(options) {
+        await super.init(options);
+        const { initCode, instanceId, kernelClientId } = options;
+        const baseURL = this.buildBaseURL({
+            instanceId,
+            kernelClientId,
+            framework: JupyterPackFramework.TORNADO
+        });
+        const bootstrapCode = `
+    from jupyterpack.common import set_base_url_env, patch_tornado
+    set_base_url_env("${baseURL}")
+    patch_tornado()
+
+    `;
+        await this.executeCode({ code: bootstrapCode });
+        if (initCode) {
+            const initCodeWithUrl = initCode.replaceAll('{{base_url}}', baseURL);
+            await this.executeCode({ code: initCodeWithUrl });
+            const loaderCode = `
+      from jupyterpack.tornado import TornadoServer
+      ${this._SERVER_VAR} = TornadoServer(app, "${baseURL}")
+      `;
+            await this.executeCode({ code: loaderCode });
+        }
+    }
+    getResponseFunctionFactory(options) {
+        const { method, urlPath, headers, params, content } = options;
+        const code = `await ${this._SERVER_VAR}.get_response("${method}", "${urlPath}", headers=${JSON.stringify(headers)} , content=${stringOrNone(content)}, params=${stringOrNone(params)})`;
+        return code;
+    }
+    openWebsocketFunctionFactory(options) {
+        const { instanceId, kernelId, wsUrl, protocol } = options;
+        const code = `await ${this._SERVER_VAR}.open_ws("${instanceId}", "${kernelId}", "${wsUrl}", ${stringOrNone(protocol)})`;
+        return code;
+    }
+    sendWebsocketMessageFunctionFactory(options) {
+        const { instanceId, kernelId, wsUrl, message } = options;
+        const code = `await ${this._SERVER_VAR}.receive_ws_message("${instanceId}", "${kernelId}", "${wsUrl}", '''${message}''')`;
+        return code;
+    }
+    async disposePythonServer() {
+        await this.executeCode({
+            code: `${this._SERVER_VAR}.dispose()`
+        });
+    }
+    async reloadPythonServer(options) {
+        var _a;
+        const { initCode } = options;
+        if (initCode) {
+            await this.executeCode({
+                code: initCode.replaceAll('{{base_url}}', (_a = this._baseUrl) !== null && _a !== void 0 ? _a : '')
+            });
+            const reloadCode = `
+      ${this._SERVER_VAR}.dispose()
+      ${this._SERVER_VAR}.reload(app)
+      `;
+            await this.executeCode({ code: reloadCode }, true);
+        }
+    }
+}

package/lib/pythonWidget/comm.d.ts

@@ -0,0 +1,11 @@
+import { Kernel } from '@jupyterlab/services';
+export declare class CommBroadcastManager {
+    constructor();
+    registerKernel(kernel: Kernel.IKernelConnection): void;
+    unregisterKernel(kernelId?: string): void;
+    private _handle_comm_open;
+    dispose(): void;
+    private _kernels;
+    private _comms;
+    private _broadcastChannels;
+}

package/lib/pythonWidget/comm.js

@@ -0,0 +1,52 @@
+const COMM_NAME = 'jupyterpack:broadcast:comm';
+export class CommBroadcastManager {
+    constructor() {
+        this._handle_comm_open = async (comm, msg, kernelId) => {
+            var _a;
+            if (this._comms.has(kernelId)) {
+                (_a = this._comms.get(kernelId)) === null || _a === void 0 ? void 0 : _a.push(comm);
+            }
+            else {
+                this._comms.set(kernelId, [comm]);
+            }
+            const channelName = msg.metadata.channel_name;
+            if (!channelName) {
+                return;
+            }
+            if (!this._broadcastChannels.has(channelName)) {
+                this._broadcastChannels.set(channelName, new BroadcastChannel(channelName));
+            }
+            const broadcastChannel = this._broadcastChannels.get(channelName);
+            comm.onMsg = commMsg => {
+                const { data } = commMsg.content;
+                broadcastChannel.postMessage(data);
+            };
+        };
+        this._kernels = new Map();
+        this._comms = new Map();
+        this._broadcastChannels = new Map();
+        this._kernels = new Map();
+        this._comms = new Map();
+    }
+    registerKernel(kernel) {
+        this._kernels.set(kernel.id, kernel);
+        kernel.registerCommTarget(COMM_NAME, (comm, msg) => this._handle_comm_open(comm, msg, kernel.id));
+    }
+    unregisterKernel(kernelId) {
+        var _a;
+        if (kernelId) {
+            this._kernels.delete(kernelId);
+            const comms = (_a = this._comms.get(kernelId)) !== null && _a !== void 0 ? _a : [];
+            comms.forEach(comm => comm.dispose());
+            this._comms.delete(kernelId);
+        }
+    }
+    dispose() {
+        this._kernels.clear();
+        this._comms.clear();
+        this._broadcastChannels.forEach(it => {
+            it.close();
+        });
+        this._broadcastChannels.clear();
+    }
+}

package/lib/pythonWidget/pythonWidget.d.ts

@@ -2,8 +2,14 @@ import { PythonWidgetModel } from './pythonWidgetModel';
 import { IFramePanel } from '../document/iframePanel';
 export declare class PythonWidget extends IFramePanel {
     constructor(options: PythonWidget.IOptions);
+    get autoreload(): boolean;
+    set autoreload(value: boolean);
+    get isReady(): Promise<void>;
     get model(): PythonWidgetModel;
+    reload(): Promise<void>;
+    dispose(): void;
     private _model;
+    private _isReady;
 }
 export declare namespace PythonWidget {
     interface IOptions {

package/lib/pythonWidget/pythonWidget.js

@@ -1,22 +1,47 @@
-import { PageConfig } from '@jupyterlab/coreutils';
+import { PageConfig, URLExt } from '@jupyterlab/coreutils';
 import { IFramePanel } from '../document/iframePanel';
+import { PromiseDelegate } from '@lumino/coreutils';
 export class PythonWidget extends IFramePanel {
     constructor(options) {
         super();
+        this._isReady = new PromiseDelegate();
         this._model = options.model;
         this._model.initialize().then(connectionData => {
-            if (!connectionData) {
+            if (!connectionData.success) {
+                this.toggleSpinner(false);
+                this._iframe.contentDocument.body.innerText = `Failed to start server: ${connectionData.error}`;
                 return;
             }
+            this._isReady.resolve();
             const iframe = this._iframe;
             const fullLabextensionsUrl = PageConfig.getOption('fullLabextensionsUrl');
-            iframe.src = `${fullLabextensionsUrl}/jupyterpack/static/${connectionData.instanceId}/dash/${connectionData.kernelClientId}/`;
+            const iframeUrl = URLExt.join(fullLabextensionsUrl, 'jupyterpack/static', connectionData.instanceId, connectionData.framework, connectionData.kernelClientId, connectionData.rootUrl);
+            iframe.src = iframeUrl;
             iframe.addEventListener('load', () => {
                 this.toggleSpinner(false);
             });
+            this._model.serverReloaded.connect(() => {
+                var _a, _b, _c;
+                (_c = (_b = (_a = this._iframe) === null || _a === void 0 ? void 0 : _a.contentWindow) === null || _b === void 0 ? void 0 : _b.location) === null || _c === void 0 ? void 0 : _c.reload();
+            });
         });
     }
+    get autoreload() {
+        return this._model.autoreload;
+    }
+    set autoreload(value) {
+        this._model.autoreload = value;
+    }
+    get isReady() {
+        return this._isReady.promise;
+    }
     get model() {
         return this._model;
     }
+    async reload() {
+        await this._model.reload();
+    }
+    dispose() {
+        this._model.dispose();
+    }
 }

package/lib/pythonWidget/pythonWidgetModel.d.ts

@@ -1,16 +1,30 @@
 import { DocumentRegistry } from '@jupyterlab/docregistry';
-import { IDisposable } from '@lumino/disposable';
-import { ServiceManager, Contents } from '@jupyterlab/services';
-import { IConnectionManager } from '../type';
-export declare class PythonWidgetModel implements IDisposable {
+import { Contents, ServiceManager } from '@jupyterlab/services';
+import { Signal } from '@lumino/signaling';
+import { IConnectionManager, IJupyterPackFileFormat, IPythonWidgetModel, JupyterPackFramework } from '../type';
+export declare class PythonWidgetModel implements IPythonWidgetModel {
     constructor(options: PythonWidgetModel.IOptions);
+    get autoreload(): boolean;
+    set autoreload(val: boolean);
     get isDisposed(): boolean;
     get connectionManager(): IConnectionManager;
+    get serverReloaded(): Signal<IPythonWidgetModel, void>;
+    get kernelStatusChanged(): Signal<IPythonWidgetModel, "started" | "stopped">;
+    reload(): Promise<void>;
     initialize(): Promise<{
+        success: true;
         instanceId: string;
         kernelClientId: string;
-    } | null>;
-    dispose(): void;
+        rootUrl: string;
+        framework: JupyterPackFramework;
+    } | {
+        success: false;
+        error: string;
+    }>;
+    dispose(): Promise<void>;
+    private _loadData;
+    private _onFileChanged;
+    private _commBroadcastManager;
     private _isDisposed;
     private _kernelStarted;
     private _sessionConnection;
@@ -18,9 +32,16 @@ export declare class PythonWidgetModel implements IDisposable {
     private _context;
     private _connectionManager;
     private _contentsManager;
+    private _jpackModel;
+    private _executor?;
+    private _localPath;
+    private _serverReloaded;
+    private _kernelStatusChanged;
+    private _autoreload;
 }
 export declare namespace PythonWidgetModel {
     interface IOptions {
+        jpackModel: IJupyterPackFileFormat;
         context: DocumentRegistry.IContext<DocumentRegistry.IModel>;
         manager: ServiceManager.IManager;
         connectionManager: IConnectionManager;

package/lib/pythonWidget/pythonWidgetModel.js

@@ -1,14 +1,31 @@
-import { PromiseDelegate } from '@lumino/coreutils';
-import { KernelExecutor } from './kernelExecutor';
 import { PathExt } from '@jupyterlab/coreutils';
+import { PromiseDelegate } from '@lumino/coreutils';
+import { PYTHON_SERVER } from '../pythonServer';
+import { Signal } from '@lumino/signaling';
+import { CommBroadcastManager } from './comm';
+import { IS_LITE } from '../tools';
 export class PythonWidgetModel {
     constructor(options) {
+        var _a, _b;
+        this._commBroadcastManager = new CommBroadcastManager();
         this._isDisposed = false;
         this._kernelStarted = false;
+        this._serverReloaded = new Signal(this);
+        this._kernelStatusChanged = new Signal(this);
         this._context = options.context;
         this._manager = options.manager;
         this._connectionManager = options.connectionManager;
         this._contentsManager = options.contentsManager;
+        this._jpackModel = options.jpackModel;
+        this._localPath = PathExt.dirname(this._context.localPath);
+        this._autoreload = Boolean((_b = (_a = this._jpackModel) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b.autoreload);
+        this._contentsManager.fileChanged.connect(this._onFileChanged, this);
+    }
+    get autoreload() {
+        return this._autoreload;
+    }
+    set autoreload(val) {
+        this._autoreload = val;
     }
     get isDisposed() {
         return this._isDisposed;
@@ -16,24 +33,42 @@ export class PythonWidgetModel {
     get connectionManager() {
         return this._connectionManager;
     }
+    get serverReloaded() {
+        return this._serverReloaded;
+    }
+    get kernelStatusChanged() {
+        return this._kernelStatusChanged;
+    }
+    async reload() {
+        var _a;
+        if (!this._kernelStarted) {
+            return;
+        }
+        const { spkContent, entryContent } = await this._loadData();
+        await ((_a = this._executor) === null || _a === void 0 ? void 0 : _a.reloadPythonServer({
+            entryPath: spkContent.entry,
+            initCode: entryContent.content
+        }));
+        this._serverReloaded.emit();
+    }
     async initialize() {
         var _a;
         if (this._kernelStarted) {
-            return null;
+            return {
+                success: false,
+                error: 'Server is called twice'
+            };
         }
-        const filePath = this._context.localPath;
-        const spkContent = this._context.model.toJSON();
-        const entryPath = PathExt.join(PathExt.dirname(filePath), spkContent.entry);
-        const entryContent = await this._contentsManager.get(entryPath, {
-            content: true,
-            format: 'text'
-        });
+        const { filePath, spkContent, rootUrl, entryContent } = await this._loadData();
         const sessionManager = this._manager.sessions;
         await sessionManager.ready;
         await this._manager.kernelspecs.ready;
         const specs = this._manager.kernelspecs.specs;
         if (!specs) {
-            return null;
+            return {
+                success: false,
+                error: 'Missing kernel spec'
+            };
         }
         const { kernelspecs } = specs;
         let kernelName = Object.keys(kernelspecs)[0];
@@ -47,13 +82,33 @@ export class PythonWidgetModel {
                 name: kernelName
             },
             type: 'notebook'
+        }, {
+            kernelConnectionOptions: { handleComms: true }
         });
-        const executor = new KernelExecutor({
+        const kernel = this._sessionConnection.kernel;
+        if (kernel) {
+            this._kernelStatusChanged.emit('started');
+            this._commBroadcastManager.registerKernel(kernel);
+            kernel.disposed.connect(() => {
+                this._kernelStatusChanged.emit('stopped');
+                this._commBroadcastManager.unregisterKernel(kernel.id);
+            });
+        }
+        const framework = spkContent.framework;
+        const ServerClass = PYTHON_SERVER.get(framework);
+        if (!ServerClass) {
+            return {
+                success: false,
+                error: `Framework "${framework}" is not supported. Please check your .spk file.`
+            };
+        }
+        const executor = (this._executor = new ServerClass({
             sessionConnection: this._sessionConnection
-        });
+        }));
         const data = await this._connectionManager.registerConnection(executor);
         await executor.init({
             initCode: entryContent.content,
+            entryPath: spkContent.entry,
             ...data
         });
         const finish = new PromiseDelegate();
@@ -67,9 +122,40 @@ export class PythonWidgetModel {
         (_a = this._sessionConnection.kernel) === null || _a === void 0 ? void 0 : _a.statusChanged.connect(cb);
         await finish.promise;
         this._kernelStarted = true;
-        return data;
+        return { ...data, rootUrl, framework, success: true };
     }
-    dispose() {
+    async dispose() {
+        var _a, _b, _c;
+        if (this._isDisposed) {
+            return;
+        }
+        if (!IS_LITE) {
+            (_b = (_a = this._sessionConnection) === null || _a === void 0 ? void 0 : _a.kernel) === null || _b === void 0 ? void 0 : _b.shutdown();
+        }
+        void ((_c = this._executor) === null || _c === void 0 ? void 0 : _c.disposePythonServer());
+        this._contentsManager.fileChanged.disconnect(this._onFileChanged);
+        this._commBroadcastManager.dispose();
         this._isDisposed = true;
     }
+    async _loadData() {
+        var _a;
+        const filePath = this._context.localPath;
+        const spkContent = this._jpackModel;
+        const entryPath = PathExt.join(PathExt.dirname(filePath), spkContent.entry);
+        const rootUrl = (_a = spkContent.rootUrl) !== null && _a !== void 0 ? _a : '/';
+        const entryContent = await this._contentsManager.get(entryPath, {
+            content: true,
+            format: 'text'
+        });
+        return { filePath, spkContent, rootUrl, entryContent };
+    }
+    async _onFileChanged(sender, args) {
+        var _a;
+        if (this._autoreload && args.type === 'save') {
+            if (((_a = args.newValue) === null || _a === void 0 ? void 0 : _a.path) &&
+                args.newValue.path.startsWith(this._localPath)) {
+                await this.reload();
+            }
+        }
+    }
 }

package/lib/sandpackWidget/sandpackFilesModel.d.ts

@@ -1,19 +1,22 @@
 import { Contents } from '@jupyterlab/services';
 import { ISignal } from '@lumino/signaling';
 import { IDict } from '../type';
-export declare class SandpackFilesModel {
+import { IDisposable } from '@lumino/disposable';
+export declare class SandpackFilesModel implements IDisposable {
     constructor(options: {
         contentsManager: Contents.IManager;
         path: string;
     });
-    getAllFiles(): Promise<IDict<{
+    getAllFiles(force?: boolean): Promise<IDict<{
         code: string;
     }>>;
+    get isDisposed(): boolean;
     get fileChanged(): ISignal<SandpackFilesModel, {
         allFiles: IDict<{
             code: string;
         }>;
     }>;
+    dispose(): void;
     flattenDirectory(dirContent: Contents.IModel): Promise<IDict<{
         code: string;
     }>>;
@@ -24,4 +27,5 @@ export declare class SandpackFilesModel {
     private _fileChanged;
     private _contentManager;
     private _allFiles?;
+    private _isDisposed;
 }

package/lib/sandpackWidget/sandpackFilesModel.js

@@ -3,12 +3,13 @@ import { removePrefix } from '../tools';
 export class SandpackFilesModel {
     constructor(options) {
         this._fileChanged = new Signal(this);
+        this._isDisposed = false;
         this._contentManager = options.contentsManager;
         this._path = options.path;
         this._contentManager.fileChanged.connect(this._onFileChanged, this);
     }
-    async getAllFiles() {
-        if (!this._allFiles) {
+    async getAllFiles(force = false) {
+        if (!this._allFiles || force) {
             const files = await this._contentManager.get(this._path, {
                 content: true
             });
@@ -16,9 +17,19 @@ export class SandpackFilesModel {
         }
         return this._allFiles;
     }
+    get isDisposed() {
+        return this._isDisposed;
+    }
     get fileChanged() {
         return this._fileChanged;
     }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        this._contentManager.fileChanged.disconnect(this._onFileChanged);
+    }
     async flattenDirectory(dirContent) {
         const flatDict = {};
         const content = dirContent.content;

package/lib/sandpackWidget/sandpackPanel.d.ts

@@ -2,15 +2,24 @@ import { SandpackClient } from '@codesandbox/sandpack-client';
 import { DocumentRegistry } from '@jupyterlab/docregistry';
 import { Contents } from '@jupyterlab/services';
 import { IFramePanel } from '../document/iframePanel';
+import { IJupyterPackFileFormat } from '../type';
 import { SandpackFilesModel } from './sandpackFilesModel';
 export declare class SandpackPanel extends IFramePanel {
     constructor(options: {
         context: DocumentRegistry.IContext<DocumentRegistry.IModel>;
         contentsManager: Contents.IManager;
     });
-    init(localPath: string): Promise<void>;
+    dispose(): void;
+    get isReady(): Promise<void>;
+    get autoreload(): boolean;
+    set autoreload(val: boolean);
+    init(localPath: string, jpackModel: IJupyterPackFileFormat): Promise<void>;
     connectSignals(filesModel: SandpackFilesModel, sandpackClient: SandpackClient): Promise<void>;
+    reload(): Promise<void>;
     private _onFileChanged;
     private _spClient?;
     private _contentsManager;
+    private _fileModel;
+    private _autoreload;
+    private _isReady;
 }

package/lib/sandpackWidget/sandpackPanel.js

@@ -1,20 +1,46 @@
 import { loadSandpackClient } from '@codesandbox/sandpack-client';
 import { IFramePanel } from '../document/iframePanel';
 import { SandpackFilesModel } from './sandpackFilesModel';
+import { PromiseDelegate } from '@lumino/coreutils';
 export class SandpackPanel extends IFramePanel {
     constructor(options) {
         super();
+        this._autoreload = false;
+        this._isReady = new PromiseDelegate();
         this._contentsManager = options.contentsManager;
+        const { context } = options;
         options.context.ready.then(async () => {
-            await this.init(options.context.localPath);
+            const jpackModel = context.model.toJSON();
+            await this.init(context.localPath, jpackModel);
         });
     }
-    async init(localPath) {
+    dispose() {
+        var _a, _b, _c;
+        (_a = this._fileModel) === null || _a === void 0 ? void 0 : _a.fileChanged.disconnect(this._onFileChanged);
+        (_b = this._fileModel) === null || _b === void 0 ? void 0 : _b.dispose();
+        (_c = this._spClient) === null || _c === void 0 ? void 0 : _c.destroy();
+        super.dispose();
+    }
+    get isReady() {
+        return this._isReady.promise;
+    }
+    get autoreload() {
+        return this._autoreload;
+    }
+    set autoreload(val) {
+        this._autoreload = val;
+    }
+    async init(localPath, jpackModel) {
+        var _a;
+        if (((_a = jpackModel === null || jpackModel === void 0 ? void 0 : jpackModel.metadata) === null || _a === void 0 ? void 0 : _a.autoreload) === true) {
+            this._autoreload = true;
+        }
         const currentDir = localPath.split('/').slice(0, -1).join('/');
         const filesModel = new SandpackFilesModel({
             contentsManager: this._contentsManager,
             path: currentDir
         });
+        this._fileModel = filesModel;
         const allFiles = await filesModel.getAllFiles();
         const options = {
             showLoadingScreen: true,
@@ -24,6 +50,7 @@ export class SandpackPanel extends IFramePanel {
             files: allFiles
         }, options);
         await this.connectSignals(filesModel, this._spClient);
+        this._isReady.resolve();
     }
     async connectSignals(filesModel, sandpackClient) {
         filesModel.fileChanged.connect(this._onFileChanged, this);
@@ -42,8 +69,16 @@ export class SandpackPanel extends IFramePanel {
             }
         });
     }
+    async reload() {
+        if (this._spClient && this._fileModel) {
+            const allFiles = await this._fileModel.getAllFiles();
+            this._spClient.updateSandbox({
+                files: allFiles
+            });
+        }
+    }
     _onFileChanged(sender, { allFiles }) {
-        if (this._spClient) {
+        if (this._autoreload && this._spClient) {
             this._spClient.updateSandbox({
                 files: allFiles
             });

package/lib/swConnection/index.js

@@ -3,7 +3,7 @@ import { UUID } from '@lumino/coreutils';
 import { expose } from 'comlink';
 import { IConnectionManagerToken } from '../token';
 import { MessageAction } from '../type';
-import { ConnectionManager } from './connection_manager';
+import { ConnectionManager } from './mainConnectionManager';
 const fullLabextensionsUrl = PageConfig.getOption('fullLabextensionsUrl');
 const SCOPE = `${fullLabextensionsUrl}/jupyterpack/static`;
 async function initServiceWorker() {
@@ -50,12 +50,12 @@ export const swPlugin = {
     autoStart: true,
     provides: IConnectionManagerToken,
     activate: async (app) => {
-        console.log('Activating jupyterpack service worker');
         const serviceWorker = await initServiceWorker();
         if (!serviceWorker) {
             throw new Error('Failed to register the Service Worker, please make sure to use a browser that supports this feature.');
         }
         const instanceId = UUID.uuid4();
+        console.log('Activating jupyterpack service worker with instance id', instanceId);
         const { port1: mainToServiceWorker, port2: serviceWorkerToMain } = new MessageChannel();
         const connectionManager = new ConnectionManager(instanceId);
         expose(connectionManager, mainToServiceWorker);

package/lib/{pythonWidget/connectionManager.d.ts → swConnection/mainConnectionManager.d.ts}

@@ -1,4 +1,12 @@
 import { IConnectionManager, IDict, IKernelExecutor } from '../type';
+/**
+ * Manages connections between clients and kernel executors.
+ * This class handles the registration of kernel executors and the generation of responses
+ * for client requests. It maintains a mapping of kernel client IDs to their respective executors.
+ * The HTTP requests intercepted by the service worker are forwarded to the appropriate kernel executor.
+ * The websocket messages forwarded from the broadcast channel are also forwarded to the appropriate kernel executor.
+ * It's running on the main thread
+ */
 export declare class ConnectionManager implements IConnectionManager {
     instanceId: string;
     constructor(instanceId: string);
@@ -14,5 +22,7 @@ export declare class ConnectionManager implements IConnectionManager {
         requestBody?: ArrayBuffer;
         params?: string;
     }): Promise<IDict | null>;
+    private _initWsChannel;
     private _kernelExecutors;
+    private _wsBroadcastChannel;
 }