npm - jupyterpack - Versions diffs - 0.3.0 → 0.5.1 - Mend

jupyterpack 0.3.0 → 0.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (87) hide show

package/README.md +1 -1
package/lib/document/commands.d.ts +8 -0
package/lib/document/commands.js +76 -0
package/lib/document/iframePanel.d.ts +4 -1
package/lib/document/plugin.d.ts +2 -1
package/lib/document/plugin.js +22 -4
package/lib/document/toolbar.d.ts +9 -0
package/lib/document/toolbar.js +20 -0
package/lib/document/widgetFactory.d.ts +2 -1
package/lib/document/widgetFactory.js +14 -6
package/lib/index.d.ts +1 -1
package/lib/pythonServer/baseServer.d.ts +82 -0
package/lib/pythonServer/baseServer.js +141 -0
package/lib/pythonServer/dash/dashServer.d.ts +5 -17
package/lib/pythonServer/dash/dashServer.js +19 -24
package/lib/pythonServer/index.d.ts +3 -3
package/lib/pythonServer/index.js +5 -1
package/lib/pythonServer/kernelExecutor.d.ts +2 -53
package/lib/pythonServer/kernelExecutor.js +5 -70
package/lib/pythonServer/shiny/shinyServer.d.ts +14 -0
package/lib/pythonServer/shiny/shinyServer.js +49 -0
package/lib/pythonServer/starlette/starletteServer.d.ts +13 -0
package/lib/pythonServer/starlette/starletteServer.js +49 -0
package/lib/pythonServer/streamlit/streamlitServer.d.ts +6 -26
package/lib/pythonServer/streamlit/streamlitServer.js +33 -41
package/lib/pythonServer/tornado/tornadoServer.d.ts +6 -26
package/lib/pythonServer/tornado/tornadoServer.js +28 -36
package/lib/pythonWidget/comm.d.ts +11 -0
package/lib/pythonWidget/comm.js +52 -0
package/lib/pythonWidget/pythonWidget.d.ts +5 -0
package/lib/pythonWidget/pythonWidget.js +19 -0
package/lib/pythonWidget/pythonWidgetModel.d.ts +16 -4
package/lib/pythonWidget/pythonWidgetModel.js +77 -13
package/lib/sandpackWidget/sandpackFilesModel.d.ts +6 -2
package/lib/sandpackWidget/sandpackFilesModel.js +13 -2
package/lib/sandpackWidget/sandpackPanel.d.ts +10 -1
package/lib/sandpackWidget/sandpackPanel.js +38 -3
package/lib/swConnection/mainConnectionManager.d.ts +4 -4
package/lib/swConnection/mainConnectionManager.js +23 -12
package/lib/token.d.ts +2 -1
package/lib/token.js +1 -0
package/lib/tools.d.ts +6 -0
package/lib/tools.js +25 -0
package/lib/type.d.ts +39 -4
package/lib/type.js +2 -0
package/lib/websocket/websocket.js +5 -1
package/package.json +6 -6
package/src/document/commands.ts +91 -0
package/src/document/iframePanel.ts +4 -1
package/src/document/plugin.ts +28 -7
package/src/document/toolbar.ts +39 -0
package/src/document/widgetFactory.ts +16 -6
package/src/global.d.ts +5 -0
package/src/pythonServer/baseServer.ts +245 -0
package/src/pythonServer/dash/dashServer.ts +25 -35
package/src/pythonServer/index.ts +9 -5
package/src/pythonServer/kernelExecutor.ts +8 -147
package/src/pythonServer/shiny/shinyServer.ts +62 -0
package/src/pythonServer/starlette/starletteServer.ts +59 -0
package/src/pythonServer/streamlit/streamlitServer.ts +40 -62
package/src/pythonServer/tornado/tornadoServer.ts +33 -60
package/src/pythonWidget/comm.ts +65 -0
package/src/pythonWidget/pythonWidget.ts +19 -1
package/src/pythonWidget/pythonWidgetModel.ts +107 -20
package/src/sandpackWidget/sandpackFilesModel.ts +17 -3
package/src/sandpackWidget/sandpackPanel.ts +45 -4
package/src/swConnection/mainConnectionManager.ts +28 -20
package/src/token.ts +5 -1
package/src/tools.ts +31 -0
package/src/type.ts +46 -7
package/src/websocket/websocket.ts +9 -1
package/style/base.css +7 -0
package/style/icons/autoreload.svg +16 -0
package/style/icons/box.svg +12 -0
package/style/icons/externallink.svg +10 -0
package/lib/pythonServer/common/generatedPythonFiles.d.ts +0 -2
package/lib/pythonServer/common/generatedPythonFiles.js +0 -72
package/lib/pythonServer/dash/generatedPythonFiles.d.ts +0 -2
package/lib/pythonServer/dash/generatedPythonFiles.js +0 -31
package/lib/pythonServer/streamlit/generatedPythonFiles.d.ts +0 -2
package/lib/pythonServer/streamlit/generatedPythonFiles.js +0 -147
package/lib/pythonServer/tornado/generatedPythonFiles.d.ts +0 -3
package/lib/pythonServer/tornado/generatedPythonFiles.js +0 -456
package/src/pythonServer/common/generatedPythonFiles.ts +0 -73
package/src/pythonServer/dash/generatedPythonFiles.ts +0 -32
package/src/pythonServer/streamlit/generatedPythonFiles.ts +0 -148
package/src/pythonServer/tornado/generatedPythonFiles.ts +0 -457

package/src/pythonServer/kernelExecutor.ts CHANGED Viewed

@@ -1,139 +1,17 @@
-import { PageConfig, URLExt } from '@jupyterlab/coreutils';
 import { KernelMessage, Session } from '@jupyterlab/services';
 import stripAnsi from 'strip-ansi';
-import {
-  arrayBufferToBase64,
-  base64ToArrayBuffer,
-  base64ToString,
-  isBinaryContentType
-} from '../tools';
-import { IDict, IKernelExecutor, JupyterPackFramework } from '../type';
-import websocketPatch from '../websocket/websocket.js?raw';
-import { patch } from './common/generatedPythonFiles';
-export abstract class KernelExecutor implements IKernelExecutor {
+import { IKernelExecutor } from '../type';
+export class KernelExecutor implements IKernelExecutor {
   constructor(options: KernelExecutor.IOptions) {
     this._sessionConnection = options.sessionConnection;
-    this._wsPatch = websocketPatch.replaceAll('"use strict";', '');
   }
   get isDisposed(): boolean {
     return this._isDisposed;
   }
-  abstract disposePythonServer(): Promise<void>;
-  abstract getResponseFunctionFactory(options: {
-    urlPath: string;
-    method: string;
-    headers: IDict;
-    params?: string;
-    content?: string;
-  }): string;
-  async init(options: {
-    entryPath?: string;
-    initCode?: string;
-    instanceId: string;
-    kernelClientId: string;
-  }): Promise<void> {
-    await this.executeCode({ code: patch });
-  }
-  openWebsocketFunctionFactory(options: {
-    instanceId: string;
-    kernelId: string;
-    wsUrl: string;
-    protocol?: string;
-  }): string | undefined {
-    return undefined;
-  }
-  sendWebsocketMessageFunctionFactory(options: {
-    instanceId: string;
-    kernelId: string;
-    wsUrl: string;
-    message: string;
-  }): string | undefined {
-    return undefined;
-  }
-  async openWebsocket(options: {
-    instanceId: string;
-    kernelId: string;
-    wsUrl: string;
-    protocol?: string;
-  }): Promise<void> {
-    const code = this.openWebsocketFunctionFactory(options);
-    if (code) {
-      await this.executeCode({ code });
-    }
-  }
-  async sendWebsocketMessage(options: {
-    instanceId: string;
-    kernelId: string;
-    wsUrl: string;
-    message: string;
-  }): Promise<void> {
-    const code = this.sendWebsocketMessageFunctionFactory(options);
-    if (code) {
-      await this.executeCode({ code });
-    }
-  }
-  async getResponse(options: {
-    method: string;
-    urlPath: string;
-    headers: IDict;
-    requestBody?: ArrayBuffer;
-    params?: string;
-  }): Promise<IDict> {
-    const { method, urlPath, requestBody, params, headers } = options;
-    const content = requestBody ? arrayBufferToBase64(requestBody) : undefined;
-    const code = this.getResponseFunctionFactory({
-      method,
-      urlPath,
-      headers,
-      params,
-      content
-    });
-    const raw = await this.executeCode({ code }, true);
-    if (!raw) {
-      throw new Error(`Missing response for ${urlPath}`);
-    }
-    const jsonStr = raw.replaceAll("'", '');
-    const obj: {
-      headers: string;
-      status_code: number;
-      content: string;
-    } = JSON.parse(jsonStr);
-    const responseHeaders: IDict<string> = JSON.parse(atob(obj.headers));
-    const contentType: string | undefined =
-      responseHeaders?.['Content-Type'] ?? responseHeaders?.['content-type'];
-    let responseContent: string | Uint8Array;
-    if (isBinaryContentType(contentType)) {
-      responseContent = base64ToArrayBuffer(obj.content);
-    } else {
-      responseContent = base64ToString(obj.content);
-    }
-    if (contentType && contentType.toLowerCase() === 'text/html') {
-      responseContent = (responseContent as string).replace(
-        '<head>',
-        `<head>\n<script>\n${this._wsPatch}\n</script>\n`
-      );
-    }
-    const decodedObj = {
-      status_code: obj.status_code,
-      headers: responseHeaders,
-      content: responseContent
-    };
-    return decodedObj;
-  }
   async executeCode(
     code: KernelMessage.IExecuteRequestMsg['content'],
     waitForResult?: boolean
@@ -160,10 +38,13 @@ export abstract class KernelExecutor implements IKernelExecutor {
           }
           case 'stream': {
             const content = (msg as KernelMessage.IStreamMsg).content;
+            if (content.text.length === 0) {
+              break;
+            }
             if (content.name === 'stderr') {
-              console.error('Kernel stream', content.text);
+              console.error('Kernel stream:', content.text);
             } else {
-              console.log('Kernel stream', content.text);
+              console.log('Kernel stream:', content.text);
             }
             break;
           }
@@ -198,28 +79,8 @@ export abstract class KernelExecutor implements IKernelExecutor {
     this._sessionConnection.dispose();
   }
-  protected buildBaseURL(options: {
-    instanceId: string;
-    kernelClientId: string;
-    framework: JupyterPackFramework;
-  }) {
-    const { instanceId, kernelClientId, framework } = options;
-    const labBaseUrl = PageConfig.getOption('baseUrl');
-    const baseURL = URLExt.join(
-      labBaseUrl,
-      'extensions/jupyterpack/static',
-      instanceId,
-      framework,
-      kernelClientId,
-      '/'
-    );
-    return baseURL;
-  }
   private _isDisposed: boolean = false;
   private _sessionConnection: Session.ISessionConnection;
-  private _wsPatch: string;
 }
 export namespace KernelExecutor {

package/src/pythonServer/shiny/shinyServer.ts ADDED Viewed

@@ -0,0 +1,62 @@
+import { JupyterPackFramework } from '../../type';
+import { BasePythonServer } from '../baseServer';
+export class ShinyServer extends BasePythonServer {
+  async init(options: {
+    entryPath?: string;
+    initCode?: string;
+    instanceId: string;
+    kernelClientId: string;
+  }) {
+    await super.init(options);
+    const { instanceId, kernelClientId, entryPath } = options;
+    const baseURL = this.buildBaseURL({
+      instanceId,
+      kernelClientId,
+      framework: JupyterPackFramework.SHINY
+    });
+    const bootstrapCode = `
+    from jupyterpack.common import set_base_url_env
+    set_base_url_env("${baseURL}")
+    from jupyterpack.shiny import patch_shiny
+    patch_shiny()
+    `;
+    await this.kernelExecutor.executeCode({ code: bootstrapCode });
+    if (entryPath) {
+      const loaderCode = `
+      from jupyterpack.shiny import ShinyServer, get_shiny_app
+      ${this._server_var} = ShinyServer(get_shiny_app("${entryPath}"), "${baseURL}")
+      `;
+      await this.kernelExecutor.executeCode({ code: loaderCode });
+    }
+  }
+  async disposePythonServer(): Promise<void> {
+    await this.kernelExecutor.executeCode({
+      code: `${this._server_var}.dispose()`
+    });
+    for (const element of this._openedWebsockets) {
+      await this.closeWebsocket(element);
+    }
+  }
+  async reloadPythonServer(options: {
+    entryPath?: string;
+    initCode?: string;
+  }): Promise<void> {
+    const { entryPath } = options;
+    if (entryPath) {
+      const reloadCode = `
+      from jupyterpack.shiny import  get_shiny_app
+      await ${this._server_var}.dispose()
+      ${this._server_var}.reload(get_shiny_app("${entryPath}"))
+      `;
+      await this.kernelExecutor.executeCode({ code: reloadCode }, true);
+    }
+  }
+}

package/src/pythonServer/starlette/starletteServer.ts ADDED Viewed

@@ -0,0 +1,59 @@
+import { JupyterPackFramework } from '../../type';
+import { BasePythonServer } from '../baseServer';
+export class StarletteServer extends BasePythonServer {
+  async init(options: {
+    initCode?: string;
+    instanceId: string;
+    kernelClientId: string;
+  }) {
+    await super.init(options);
+    const { initCode, instanceId, kernelClientId } = options;
+    const baseURL = this.buildBaseURL({
+      instanceId,
+      kernelClientId,
+      framework: JupyterPackFramework.STARLETTE
+    });
+    const bootstrapCode = `
+    from jupyterpack.common import set_base_url_env
+    set_base_url_env("${baseURL}")
+    `;
+    await this.kernelExecutor.executeCode({ code: bootstrapCode });
+    if (initCode) {
+      const initCodeWithUrl = initCode.replaceAll('{{base_url}}', baseURL);
+      await this.kernelExecutor.executeCode({ code: initCodeWithUrl });
+      const loaderCode = `
+      from jupyterpack.asgi import AsgiServer
+      ${this._server_var} = AsgiServer(app, "${baseURL}")
+      `;
+      await this.kernelExecutor.executeCode({ code: loaderCode });
+    }
+  }
+  async disposePythonServer(): Promise<void> {
+    await this.kernelExecutor.executeCode({
+      code: `${this._server_var}.dispose()`
+    });
+    for (const element of this._openedWebsockets) {
+      await this.closeWebsocket(element);
+    }
+  }
+  async reloadPythonServer(options: {
+    entryPath?: string;
+    initCode?: string;
+  }): Promise<void> {
+    const { initCode } = options;
+    if (initCode) {
+      await this.kernelExecutor.executeCode({
+        code: initCode.replaceAll('{{base_url}}', this._baseUrl ?? '')
+      });
+      const reloadCode = `
+      await ${this._server_var}.dispose()
+      ${this._server_var}.reload(app)
+      `;
+      await this.kernelExecutor.executeCode({ code: reloadCode }, true);
+    }
+  }
+}

package/src/pythonServer/streamlit/streamlitServer.ts CHANGED Viewed

@@ -1,21 +1,13 @@
-import { stringOrNone } from '../../tools';
-import { IDict, JupyterPackFramework } from '../../type';
-import { patch, tools } from '../common/generatedPythonFiles';
-import { KernelExecutor } from '../kernelExecutor';
-import {
-  bootstrap as tornadoBootstrap,
-  tornadoBridge
-} from '../tornado/generatedPythonFiles';
-import { bootstrap, streamlitLoader } from './generatedPythonFiles';
+import { JupyterPackFramework } from '../../type';
+import { TornadoServer } from '../tornado/tornadoServer';
-export class StreamlitServer extends KernelExecutor {
+export class StreamlitServer extends TornadoServer {
   async init(options: {
     entryPath?: string;
     initCode?: string;
     instanceId: string;
     kernelClientId: string;
   }) {
-    await super.init(options);
     const { instanceId, kernelClientId, entryPath } = options;
     if (!entryPath) {
       throw new Error(
@@ -27,61 +19,47 @@ export class StreamlitServer extends KernelExecutor {
       kernelClientId,
       framework: JupyterPackFramework.STREAMLIT
     });
-    await this.executeCode({ code: patch });
-    await this.executeCode({ code: tools.replaceAll('{{base_url}}', baseURL) });
-    await this.executeCode({ code: tornadoBootstrap });
-    await this.executeCode({ code: tornadoBridge });
-    await this.executeCode({ code: bootstrap });
-    const stCode = streamlitLoader
-      .replaceAll('{{base_url}}', baseURL)
-      .replaceAll('{{script_path}}', entryPath);
-    await this.executeCode({ code: stCode });
-  }
+    const patchCode = `
+    from jupyterpack.common import set_base_url_env, patch_tornado, patch_all
+    patch_all()
+    patch_tornado()
+    set_base_url_env("${baseURL}")
+    `;
+    await this.kernelExecutor.executeCode({ code: patchCode });
-  getResponseFunctionFactory(options: {
-    urlPath: string;
-    method: string;
-    headers: IDict;
-    params?: string;
-    content?: string;
-  }) {
-    const { method, urlPath, headers, params, content } = options;
-    const code = `await ${this._GET_RESPONSE_FUNCTION}("${method}", "${urlPath}", headers=${JSON.stringify(headers)} , content=${stringOrNone(content)}, params=${stringOrNone(params)})`;
-    return code;
-  }
+    const bootstrapCode = `
+    from jupyterpack.streamlit import patch_streamlit
+    patch_streamlit()
+    `;
+    await this.kernelExecutor.executeCode({ code: bootstrapCode });
-  openWebsocketFunctionFactory(options: {
-    instanceId: string;
-    kernelId: string;
-    wsUrl: string;
-    protocol?: string;
-  }): string {
-    const { instanceId, kernelId, wsUrl, protocol } = options;
-    const code = `await ${this._OPEN_WEBSOCKET_FUNCTION}("${instanceId}", "${kernelId}", "${wsUrl}", ${stringOrNone(protocol)})`;
-    return code;
+    const stCode = `
+      from jupyterpack.streamlit import StreamlitServer, create_streamlit_app
+      __jupyterpack_st_server, __jupyterpack_tor_app = await create_streamlit_app("${entryPath}", "${baseURL}")
+      ${this._server_var} = StreamlitServer(__jupyterpack_tor_app, "${baseURL}", __jupyterpack_st_server)
+      `;
+    await this.kernelExecutor.executeCode({ code: stCode });
   }
-  sendWebsocketMessageFunctionFactory(options: {
-    instanceId: string;
-    kernelId: string;
-    wsUrl: string;
-    message: string;
-  }): string {
-    const { instanceId, kernelId, wsUrl, message } = options;
-    const code = `await ${this._SEND_WEBSOCKET_FUNCTION}("${instanceId}", "${kernelId}", "${wsUrl}", '''${message}''')`;
-    return code;
-  }
-  async disposePythonServer(): Promise<void> {
-    await this.executeCode({
-      code: '__jupyterpack_streamlit_dispose()'
-    });
+  async reloadPythonServer(options: {
+    entryPath?: string;
+    initCode?: string;
+  }): Promise<void> {
+    const { entryPath } = options;
+    if (!entryPath || !this._baseUrl) {
+      return;
+    }
+    const reloadCode = `
+      ${this._server_var}.dispose()
+      __jupyterpack_st_server, __jupyterpack_tor_app = await create_streamlit_app("${entryPath}", "${this._baseUrl}")
+      ${this._server_var}.reload(__jupyterpack_tor_app, __jupyterpack_st_server)
+      `;
+    await this.kernelExecutor.executeCode(
+      {
+        code: reloadCode
+      },
+      true
+    );
   }
-  private _GET_RESPONSE_FUNCTION = '__jupyterpack_streamlit_get_response';
-  private _OPEN_WEBSOCKET_FUNCTION = '__jupyterpack_streamlit_open_ws';
-  private _SEND_WEBSOCKET_FUNCTION =
-    '__jupyterpack_streamlit_receive_ws_message';
 }

package/src/pythonServer/tornado/tornadoServer.ts CHANGED Viewed

@@ -1,13 +1,7 @@
-import { stringOrNone } from '../../tools';
-import { IDict, JupyterPackFramework } from '../../type';
-import { tools } from '../common/generatedPythonFiles';
-import { KernelExecutor } from '../kernelExecutor';
-import {
-  bootstrap,
-  tornadoBridge,
-  tornadoLoader
-} from './generatedPythonFiles';
-export class TornadoServer extends KernelExecutor {
+import { JupyterPackFramework } from '../../type';
+import { BasePythonServer } from '../baseServer';
+export class TornadoServer extends BasePythonServer {
   async init(options: {
     initCode?: string;
     instanceId: string;
@@ -21,60 +15,39 @@ export class TornadoServer extends KernelExecutor {
       kernelClientId,
       framework: JupyterPackFramework.TORNADO
     });
-    await this.executeCode({ code: tools.replaceAll('{{base_url}}', baseURL) });
-    await this.executeCode({ code: bootstrap });
-    await this.executeCode({ code: tornadoBridge });
+    const bootstrapCode = `
+    from jupyterpack.common import set_base_url_env, patch_tornado
+    set_base_url_env("${baseURL}")
+    patch_tornado()
+    `;
+    await this.kernelExecutor.executeCode({ code: bootstrapCode });
     if (initCode) {
       const initCodeWithUrl = initCode.replaceAll('{{base_url}}', baseURL);
-      await this.executeCode({ code: initCodeWithUrl });
-      const torCode = tornadoLoader.replaceAll('{{base_url}}', baseURL);
-      await this.executeCode({ code: torCode });
-    }
-  }
-  getResponseFunctionFactory(options: {
-    urlPath: string;
-    method: string;
-    headers: IDict;
-    params?: string;
-    content?: string;
-  }) {
-    const { method, urlPath, headers, params, content } = options;
-    const code = `await ${this._GET_RESPONSE_FUNCTION}("${method}", "${urlPath}", headers=${JSON.stringify(headers)} , content=${stringOrNone(content)}, params=${stringOrNone(params)})`;
-    return code;
-  }
+      await this.kernelExecutor.executeCode({ code: initCodeWithUrl });
+      const loaderCode = `
+      from jupyterpack.tornado import TornadoServer
+      ${this._server_var} = TornadoServer(app, "${baseURL}")
+      `;
-  openWebsocketFunctionFactory(options: {
-    instanceId: string;
-    kernelId: string;
-    wsUrl: string;
-    protocol?: string;
-  }): string {
-    const { instanceId, kernelId, wsUrl, protocol } = options;
-    const code = `await ${this._OPEN_WEBSOCKET_FUNCTION}("${instanceId}", "${kernelId}", "${wsUrl}", ${stringOrNone(protocol)})`;
-    return code;
-  }
-  sendWebsocketMessageFunctionFactory(options: {
-    instanceId: string;
-    kernelId: string;
-    wsUrl: string;
-    message: string;
-  }): string {
-    const { instanceId, kernelId, wsUrl, message } = options;
-    const code = `await ${this._SEND_WEBSOCKET_FUNCTION}("${instanceId}", "${kernelId}", "${wsUrl}", '''${message}''')`;
-    return code;
+      await this.kernelExecutor.executeCode({ code: loaderCode });
+    }
   }
-  async disposePythonServer(): Promise<void> {
-    await this.executeCode({
-      code: '__jupyterpack_tornado_dispose()'
-    });
+  async reloadPythonServer(options: {
+    entryPath?: string;
+    initCode?: string;
+  }): Promise<void> {
+    const { initCode } = options;
+    if (initCode) {
+      await this.kernelExecutor.executeCode({
+        code: initCode.replaceAll('{{base_url}}', this._baseUrl ?? '')
+      });
+      const reloadCode = `
+      ${this._server_var}.dispose()
+      ${this._server_var}.reload(app)
+      `;
+      await this.kernelExecutor.executeCode({ code: reloadCode }, true);
+    }
   }
-  private _GET_RESPONSE_FUNCTION = '__jupyterpack_tornado_get_response';
-  private _OPEN_WEBSOCKET_FUNCTION = '__jupyterpack_tornado_open_ws';
-  private _SEND_WEBSOCKET_FUNCTION = '__jupyterpack_tornado_receive_ws_message';
 }

package/src/pythonWidget/comm.ts ADDED Viewed

@@ -0,0 +1,65 @@
+import { Kernel, KernelMessage } from '@jupyterlab/services';
+const COMM_NAME = 'jupyterpack:broadcast:comm';
+export class CommBroadcastManager {
+  constructor() {
+    this._kernels = new Map();
+    this._comms = new Map();
+  }
+  registerKernel(kernel: Kernel.IKernelConnection) {
+    this._kernels.set(kernel.id, kernel);
+    kernel.registerCommTarget(COMM_NAME, (comm, msg) =>
+      this._handle_comm_open(comm, msg, kernel.id)
+    );
+  }
+  unregisterKernel(kernelId?: string) {
+    if (kernelId) {
+      this._kernels.delete(kernelId);
+      const comms = this._comms.get(kernelId) ?? [];
+      comms.forEach(comm => comm.dispose());
+      this._comms.delete(kernelId);
+    }
+  }
+  private _handle_comm_open = async (
+    comm: Kernel.IComm,
+    msg: KernelMessage.ICommOpenMsg,
+    kernelId: string
+  ): Promise<void> => {
+    if (this._comms.has(kernelId)) {
+      this._comms.get(kernelId)?.push(comm);
+    } else {
+      this._comms.set(kernelId, [comm]);
+    }
+    const channelName = msg.metadata.channel_name as string | undefined;
+    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);
+    };
+  };
+  dispose() {
+    this._kernels.clear();
+    this._comms.clear();
+    this._broadcastChannels.forEach(it => {
+      it.close();
+    });
+    this._broadcastChannels.clear();
+  }
+  private _kernels: Map<string, Kernel.IKernelConnection> = new Map();
+  private _comms: Map<string, Kernel.IComm[]> = new Map();
+  private _broadcastChannels: Map<string, BroadcastChannel> = new Map();
+}

package/src/pythonWidget/pythonWidget.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import { PythonWidgetModel } from './pythonWidgetModel';
 import { PageConfig, URLExt } from '@jupyterlab/coreutils';
 import { IFramePanel } from '../document/iframePanel';
+import { PromiseDelegate } from '@lumino/coreutils';
 export class PythonWidget extends IFramePanel {
   constructor(options: PythonWidget.IOptions) {
@@ -12,6 +13,7 @@ export class PythonWidget extends IFramePanel {
         this._iframe.contentDocument!.body.innerText = `Failed to start server: ${connectionData.error}`;
         return;
       }
+      this._isReady.resolve();
       const iframe = this._iframe;
       const fullLabextensionsUrl = PageConfig.getOption('fullLabextensionsUrl');
@@ -23,24 +25,40 @@ export class PythonWidget extends IFramePanel {
         connectionData.kernelClientId,
         connectionData.rootUrl
       );
       iframe.src = iframeUrl;
       iframe.addEventListener('load', () => {
         this.toggleSpinner(false);
       });
+      this._model.serverReloaded.connect(() => {
+        this._iframe?.contentWindow?.location?.reload();
+      });
     });
   }
+  get autoreload() {
+    return this._model.autoreload;
+  }
+  set autoreload(value: boolean) {
+    this._model.autoreload = value;
+  }
+  get isReady(): Promise<void> {
+    return this._isReady.promise;
+  }
   get model(): PythonWidgetModel {
     return this._model;
   }
+  async reload(): Promise<void> {
+    await this._model.reload();
+  }
   dispose(): void {
     this._model.dispose();
   }
   private _model: PythonWidgetModel;
+  private _isReady = new PromiseDelegate<void>();
 }
 export namespace PythonWidget {