jupyterpack 0.3.0 → 0.4.0

package/lib/document/commands.d.ts

@@ -0,0 +1,8 @@
+import { CommandRegistry } from '@lumino/commands';
+import { IJupyterpackDocTracker } from '../type';
+export declare const CommandIDs: {
+    RELOAD: string;
+    TOGGLE_AUTORELOAD: string;
+    OPEN_SPECTA: string;
+};
+export declare function addCommands(commands: CommandRegistry, tracker: IJupyterpackDocTracker): void;

package/lib/document/commands.js

@@ -0,0 +1,76 @@
+import { refreshIcon } from '@jupyterlab/ui-components';
+import { autoReloadIcon, linkIcon } from '../tools';
+import { PageConfig, URLExt } from '@jupyterlab/coreutils';
+export const CommandIDs = {
+    RELOAD: 'jupyterpack:reload',
+    TOGGLE_AUTORELOAD: 'jupyterpack:toggleAutoreload',
+    OPEN_SPECTA: 'jupyterpack:openInSpecta'
+};
+const labBaseUrl = PageConfig.getOption('baseUrl');
+function getCurrentIframPanel(tracker) {
+    var _a;
+    const current = (_a = tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.content;
+    if (!current) {
+        return;
+    }
+    const widget = current.widgets[0];
+    if (!widget) {
+        return;
+    }
+    return widget;
+}
+export function addCommands(commands, tracker) {
+    commands.addCommand(CommandIDs.RELOAD, {
+        caption: 'Reload',
+        isEnabled: () => {
+            return tracker.currentWidget !== null;
+        },
+        icon: refreshIcon,
+        execute: async () => {
+            const widget = getCurrentIframPanel(tracker);
+            if (widget) {
+                await widget.reload();
+            }
+        }
+    });
+    const commandState = { toggled: false };
+    commands.addCommand(CommandIDs.TOGGLE_AUTORELOAD, {
+        isEnabled: () => {
+            return tracker.currentWidget !== null;
+        },
+        isToggled: () => {
+            const widget = getCurrentIframPanel(tracker);
+            return Boolean(widget === null || widget === void 0 ? void 0 : widget.autoreload);
+        },
+        icon: autoReloadIcon,
+        caption: e => {
+            return commandState.toggled
+                ? 'Auto-reload enabled'
+                : 'Auto-reload disabled';
+        },
+        execute: async () => {
+            const widget = getCurrentIframPanel(tracker);
+            if (widget) {
+                widget.autoreload = !(widget === null || widget === void 0 ? void 0 : widget.autoreload);
+                commands.notifyCommandChanged(CommandIDs.TOGGLE_AUTORELOAD);
+            }
+        }
+    });
+    commands.addCommand(CommandIDs.OPEN_SPECTA, {
+        caption: 'Open in Specta',
+        isEnabled: () => {
+            return tracker.currentWidget !== null;
+        },
+        icon: linkIcon,
+        execute: async () => {
+            var _a;
+            const context = (_a = tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.context;
+            if (!context) {
+                return;
+            }
+            const spectaUrl = new URL(URLExt.join(labBaseUrl, 'specta'), window.location.origin);
+            spectaUrl.searchParams.set('path', context.path);
+            window.open(spectaUrl.toString(), '_blank');
+        }
+    });
+}

package/lib/document/iframePanel.d.ts

@@ -1,7 +1,10 @@
 import { Widget } from '@lumino/widgets';
-export declare class IFramePanel extends Widget {
+export declare abstract class IFramePanel extends Widget {
     constructor();
     toggleSpinner(show: boolean): void;
+    abstract reload(): Promise<void>;
+    abstract autoreload: boolean;
+    abstract isReady: Promise<void>;
     protected _iframe: HTMLIFrameElement;
     protected _spinner: HTMLDivElement;
 }

package/lib/document/plugin.d.ts

@@ -1,2 +1,3 @@
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
-export declare const spkPlugin: JupyterFrontEndPlugin<void>;
+import { IJupyterpackDocTracker } from '../type';
+export declare const spkPlugin: JupyterFrontEndPlugin<IJupyterpackDocTracker>;

package/lib/document/plugin.js

@@ -1,12 +1,20 @@
 import { JupyterPackWidgetFactory } from './widgetFactory';
-import { IConnectionManagerToken } from '../token';
+import { IConnectionManagerToken, IJupyterpackDocTrackerToken } from '../token';
+import { WidgetTracker } from '@jupyterlab/apputils';
+import { logoIcon } from '../tools';
+import { addCommands } from './commands';
 const FACTORY = 'jupyterpack';
 const CONTENT_TYPE = 'jupyterpack';
 export const spkPlugin = {
     id: 'jupyterpack:spkplugin',
     requires: [IConnectionManagerToken],
     autoStart: true,
+    provides: IJupyterpackDocTrackerToken,
     activate: (app, connectionManager) => {
+        const tracker = new WidgetTracker({
+            namespace: FACTORY
+        });
+        addCommands(app.commands, tracker);
         const widgetFactory = new JupyterPackWidgetFactory({
             name: FACTORY,
             modelName: 'text',
@@ -14,7 +22,8 @@ export const spkPlugin = {
             defaultFor: [CONTENT_TYPE],
             commands: app.commands,
             manager: app.serviceManager,
-            connectionManager
+            connectionManager,
+            tracker
         });
         // Registering the widget factory
         app.docRegistry.addWidgetFactory(widgetFactory);
@@ -22,10 +31,19 @@ export const spkPlugin = {
         app.docRegistry.addFileType({
             name: CONTENT_TYPE,
             displayName: 'SPK',
-            mimeTypes: ['text/json'],
+            mimeTypes: ['application/json'],
             extensions: ['.spk', '.SPK'],
             fileFormat: 'json',
-            contentType: CONTENT_TYPE
+            contentType: CONTENT_TYPE,
+            icon: logoIcon
+        });
+        widgetFactory.widgetCreated.connect((_, widget) => {
+            widget.title.icon = logoIcon;
+            widget.context.pathChanged.connect(() => {
+                tracker.save(widget);
+            });
+            tracker.add(widget);
         });
+        return tracker;
     }
 };

package/lib/document/toolbar.d.ts

@@ -0,0 +1,9 @@
+import { ReactiveToolbar } from '@jupyterlab/ui-components';
+import { CommandRegistry } from '@lumino/commands';
+import { IJupyterpackDocTracker } from '../type';
+export declare class ToolbarWidget extends ReactiveToolbar {
+    constructor(options: {
+        tracker: IJupyterpackDocTracker;
+        commands: CommandRegistry;
+    });
+}

package/lib/document/toolbar.js

@@ -0,0 +1,20 @@
+import { CommandToolbarButton, ReactiveToolbar } from '@jupyterlab/ui-components';
+import { CommandIDs } from './commands';
+export class ToolbarWidget extends ReactiveToolbar {
+    constructor(options) {
+        super();
+        this.addClass('jupyterpack-toolbar');
+        this.addItem('Reload', new CommandToolbarButton({
+            commands: options.commands,
+            id: CommandIDs.RELOAD
+        }));
+        this.addItem('Toggle Auto Reload', new CommandToolbarButton({
+            id: CommandIDs.TOGGLE_AUTORELOAD,
+            commands: options.commands
+        }));
+        this.addItem('Open Specta', new CommandToolbarButton({
+            id: CommandIDs.OPEN_SPECTA,
+            commands: options.commands
+        }));
+    }
+}

package/lib/document/widgetFactory.d.ts

@@ -1,12 +1,13 @@
 import { ABCWidgetFactory, DocumentRegistry } from '@jupyterlab/docregistry';
 import { ServiceManager } from '@jupyterlab/services';
 import { CommandRegistry } from '@lumino/commands';
-import { IConnectionManager } from '../type';
+import { IConnectionManager, IJupyterpackDocTracker } from '../type';
 import { JupyterPackDocWidget } from './jupyterpackDocWidget';
 interface IOptions extends DocumentRegistry.IWidgetFactoryOptions {
     commands: CommandRegistry;
     manager: ServiceManager.IManager;
     connectionManager: IConnectionManager;
+    tracker: IJupyterpackDocTracker;
 }
 export declare class JupyterPackWidgetFactory extends ABCWidgetFactory<JupyterPackDocWidget> {
     private options;

package/lib/document/widgetFactory.js

@@ -1,11 +1,12 @@
 import { ABCWidgetFactory } from '@jupyterlab/docregistry';
+import { UUID } from '@lumino/coreutils';
 import { Panel } from '@lumino/widgets';
-import { JupyterPackFramework } from '../type';
+import { PythonWidget } from '../pythonWidget/pythonWidget';
+import { PythonWidgetModel } from '../pythonWidget/pythonWidgetModel';
 import { SandpackPanel } from '../sandpackWidget/sandpackPanel';
+import { JupyterPackFramework } from '../type';
 import { JupyterPackDocWidget } from './jupyterpackDocWidget';
-import { PythonWidgetModel } from '../pythonWidget/pythonWidgetModel';
-import { UUID } from '@lumino/coreutils';
-import { PythonWidget } from '../pythonWidget/pythonWidget';
+import { ToolbarWidget } from './toolbar';
 export class JupyterPackWidgetFactory extends ABCWidgetFactory {
     constructor(options) {
         super(options);
@@ -55,9 +56,14 @@ export class JupyterPackWidgetFactory extends ABCWidgetFactory {
                 }
             }
         });
+        const toolbar = new ToolbarWidget({
+            tracker: this.options.tracker,
+            commands: this.options.commands
+        });
         return new JupyterPackDocWidget({
             context,
-            content
+            content,
+            toolbar
         });
     }
 }

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (import("@jupyterlab/application").JupyterFrontEndPlugin<void> | import("@jupyterlab/application").JupyterFrontEndPlugin<import("./type").IConnectionManager>)[];
+declare const _default: (import("@jupyterlab/application").JupyterFrontEndPlugin<import("./type").IJupyterpackDocTracker> | import("@jupyterlab/application").JupyterFrontEndPlugin<import("./type").IConnectionManager>)[];
 export default _default;

package/lib/pythonServer/dash/dashServer.d.ts

@@ -14,11 +14,9 @@ export declare class DashServer extends KernelExecutor {
         content?: string;
     }): string;
     disposePythonServer(): Promise<void>;
-    openWebsocket(options: {
-        instanceId: string;
-        kernelId: string;
-        wsUrl: string;
-        protocol?: string;
+    reloadPythonServer(options: {
+        entryPath?: string;
+        initCode?: string;
     }): Promise<void>;
-    private DASH_GET_RESPONSE_FUNCTION;
+    private _DASH_SERVER_VAR;
 }

package/lib/pythonServer/dash/dashServer.js

@@ -1,12 +1,10 @@
 import { stringOrNone } from '../../tools';
 import { JupyterPackFramework } from '../../type';
-import { patch } from '../common/generatedPythonFiles';
 import { KernelExecutor } from '../kernelExecutor';
-import { bootstrap, dashLoader } from './generatedPythonFiles';
 export class DashServer extends KernelExecutor {
     constructor() {
         super(...arguments);
-        this.DASH_GET_RESPONSE_FUNCTION = '__jupyterpack_dash_get_response';
+        this._DASH_SERVER_VAR = '__jupyterpack_dash_server';
     }
     async init(options) {
         await super.init(options);
@@ -16,24 +14,34 @@ export class DashServer extends KernelExecutor {
             kernelClientId,
             framework: JupyterPackFramework.DASH
         });
-        await this.executeCode({ code: patch });
         await this.executeCode({
-            code: bootstrap.replaceAll('{{base_url}}', baseURL)
+            code: `
+      import os
+      os.environ["DASH_URL_BASE_PATHNAME"] = "${baseURL}"
+      `
         });
         if (initCode) {
             await this.executeCode({ code: initCode });
         }
-        await this.executeCode({ code: dashLoader });
+        const loaderCode = `
+      from jupyterpack.dash import DashServer
+      ${this._DASH_SERVER_VAR} = DashServer(app, "${baseURL}")
+      `;
+        await this.executeCode({ code: loaderCode });
     }
     getResponseFunctionFactory(options) {
         const { method, urlPath, headers, params, content } = options;
-        const code = `${this.DASH_GET_RESPONSE_FUNCTION}("${method}", "${urlPath}", headers=${JSON.stringify(headers)} , content=${stringOrNone(content)}, params=${stringOrNone(params)})`;
+        const code = `${this._DASH_SERVER_VAR}.get_response("${method}", "${urlPath}", headers=${JSON.stringify(headers)} , content=${stringOrNone(content)}, params=${stringOrNone(params)})`;
         return code;
     }
     async disposePythonServer() {
-        //no-op
+        await this.executeCode({ code: `${this._DASH_SERVER_VAR}.dispose()` });
     }
-    async openWebsocket(options) {
-        //no-op
+    async reloadPythonServer(options) {
+        const { initCode } = options;
+        if (initCode) {
+            await this.executeCode({ code: initCode });
+        }
+        await this.executeCode({ code: `${this._DASH_SERVER_VAR}.reload(app)` }, true);
     }
 }

package/lib/pythonServer/kernelExecutor.d.ts

@@ -4,6 +4,10 @@ export declare abstract class KernelExecutor implements IKernelExecutor {
     constructor(options: KernelExecutor.IOptions);
     get isDisposed(): boolean;
     abstract disposePythonServer(): Promise<void>;
+    abstract reloadPythonServer(options: {
+        entryPath?: string;
+        initCode?: string;
+    }): Promise<void>;
     abstract getResponseFunctionFactory(options: {
         urlPath: string;
         method: string;
@@ -55,6 +59,7 @@ export declare abstract class KernelExecutor implements IKernelExecutor {
         kernelClientId: string;
         framework: JupyterPackFramework;
     }): string;
+    protected _baseUrl: string | undefined;
     private _isDisposed;
     private _sessionConnection;
     private _wsPatch;

package/lib/pythonServer/kernelExecutor.js

@@ -2,7 +2,6 @@ import { PageConfig, URLExt } from '@jupyterlab/coreutils';
 import stripAnsi from 'strip-ansi';
 import { arrayBufferToBase64, base64ToArrayBuffer, base64ToString, isBinaryContentType } from '../tools';
 import websocketPatch from '../websocket/websocket.js?raw';
-import { patch } from './common/generatedPythonFiles';
 export class KernelExecutor {
     constructor(options) {
         this._isDisposed = false;
@@ -13,7 +12,11 @@ export class KernelExecutor {
         return this._isDisposed;
     }
     async init(options) {
-        await this.executeCode({ code: patch });
+        const patchCode = `
+    from jupyterpack.common import patch_all
+    patch_all()
+    `;
+        await this.executeCode({ code: patchCode });
     }
     openWebsocketFunctionFactory(options) {
         return undefined;
@@ -92,11 +95,14 @@ export class KernelExecutor {
                     }
                     case 'stream': {
                         const content = msg.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;
                     }
@@ -126,8 +132,9 @@ export class KernelExecutor {
     }
     buildBaseURL(options) {
         const { instanceId, kernelClientId, framework } = options;
-        const labBaseUrl = PageConfig.getOption('baseUrl');
-        const baseURL = URLExt.join(labBaseUrl, 'extensions/jupyterpack/static', instanceId, framework, kernelClientId, '/');
+        const fullLabextensionsUrl = PageConfig.getOption('fullLabextensionsUrl');
+        const baseURL = URLExt.join(fullLabextensionsUrl, 'jupyterpack/static', instanceId, framework, kernelClientId, '/');
+        this._baseUrl = baseURL;
         return baseURL;
     }
 }

package/lib/pythonServer/streamlit/streamlitServer.d.ts

@@ -1,33 +1,14 @@
-import { IDict } from '../../type';
-import { KernelExecutor } from '../kernelExecutor';
-export declare class StreamlitServer extends KernelExecutor {
+import { TornadoServer } from '../tornado/tornadoServer';
+export declare class StreamlitServer extends TornadoServer {
     init(options: {
         entryPath?: string;
         initCode?: string;
         instanceId: string;
         kernelClientId: string;
     }): Promise<void>;
-    getResponseFunctionFactory(options: {
-        urlPath: string;
-        method: string;
-        headers: IDict;
-        params?: string;
-        content?: string;
-    }): string;
-    openWebsocketFunctionFactory(options: {
-        instanceId: string;
-        kernelId: string;
-        wsUrl: string;
-        protocol?: string;
-    }): string;
-    sendWebsocketMessageFunctionFactory(options: {
-        instanceId: string;
-        kernelId: string;
-        wsUrl: string;
-        message: string;
-    }): string;
-    disposePythonServer(): Promise<void>;
-    private _GET_RESPONSE_FUNCTION;
-    private _OPEN_WEBSOCKET_FUNCTION;
-    private _SEND_WEBSOCKET_FUNCTION;
+    reloadPythonServer(options: {
+        entryPath?: string;
+        initCode?: string;
+    }): Promise<void>;
+    protected _SERVER_VAR: string;
 }

package/lib/pythonServer/streamlit/streamlitServer.js

@@ -1,18 +1,11 @@
-import { stringOrNone } from '../../tools';
 import { 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';
-export class StreamlitServer extends KernelExecutor {
+import { TornadoServer } from '../tornado/tornadoServer';
+export class StreamlitServer extends TornadoServer {
     constructor() {
         super(...arguments);
-        this._GET_RESPONSE_FUNCTION = '__jupyterpack_streamlit_get_response';
-        this._OPEN_WEBSOCKET_FUNCTION = '__jupyterpack_streamlit_open_ws';
-        this._SEND_WEBSOCKET_FUNCTION = '__jupyterpack_streamlit_receive_ws_message';
+        this._SERVER_VAR = '__jupyterpack_streamlit_server';
     }
     async init(options) {
-        await super.init(options);
         const { instanceId, kernelClientId, entryPath } = options;
         if (!entryPath) {
             throw new Error('Missing streamlit entry path, please check your SPK file');
@@ -22,34 +15,37 @@ 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);
+        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.executeCode({ code: patchCode });
+        const bootstrapCode = `
+    from jupyterpack.streamlit import patch_streamlit
+    patch_streamlit()
+    `;
+        await this.executeCode({ code: bootstrapCode });
+        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.executeCode({ code: stCode });
     }
-    getResponseFunctionFactory(options) {
-        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;
-    }
-    openWebsocketFunctionFactory(options) {
-        const { instanceId, kernelId, wsUrl, protocol } = options;
-        const code = `await ${this._OPEN_WEBSOCKET_FUNCTION}("${instanceId}", "${kernelId}", "${wsUrl}", ${stringOrNone(protocol)})`;
-        return code;
-    }
-    sendWebsocketMessageFunctionFactory(options) {
-        const { instanceId, kernelId, wsUrl, message } = options;
-        const code = `await ${this._SEND_WEBSOCKET_FUNCTION}("${instanceId}", "${kernelId}", "${wsUrl}", '''${message}''')`;
-        return code;
-    }
-    async disposePythonServer() {
+    async reloadPythonServer(options) {
+        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.executeCode({
-            code: '__jupyterpack_streamlit_dispose()'
-        });
+            code: reloadCode
+        }, true);
     }
 }

package/lib/pythonServer/tornado/tornadoServer.d.ts

@@ -26,7 +26,9 @@ export declare class TornadoServer extends KernelExecutor {
         message: string;
     }): string;
     disposePythonServer(): Promise<void>;
-    private _GET_RESPONSE_FUNCTION;
-    private _OPEN_WEBSOCKET_FUNCTION;
-    private _SEND_WEBSOCKET_FUNCTION;
+    reloadPythonServer(options: {
+        entryPath?: string;
+        initCode?: string;
+    }): Promise<void>;
+    protected _SERVER_VAR: string;
 }

package/lib/pythonServer/tornado/tornadoServer.js

@@ -1,14 +1,10 @@
 import { stringOrNone } from '../../tools';
 import { JupyterPackFramework } from '../../type';
-import { tools } from '../common/generatedPythonFiles';
 import { KernelExecutor } from '../kernelExecutor';
-import { bootstrap, tornadoBridge, tornadoLoader } from './generatedPythonFiles';
 export class TornadoServer extends KernelExecutor {
     constructor() {
         super(...arguments);
-        this._GET_RESPONSE_FUNCTION = '__jupyterpack_tornado_get_response';
-        this._OPEN_WEBSOCKET_FUNCTION = '__jupyterpack_tornado_open_ws';
-        this._SEND_WEBSOCKET_FUNCTION = '__jupyterpack_tornado_receive_ws_message';
+        this._SERVER_VAR = '__jupyterpack_tornado_server';
     }
     async init(options) {
         await super.init(options);
@@ -18,34 +14,55 @@ 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.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 });
+            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._GET_RESPONSE_FUNCTION}("${method}", "${urlPath}", headers=${JSON.stringify(headers)} , content=${stringOrNone(content)}, params=${stringOrNone(params)})`;
+        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._OPEN_WEBSOCKET_FUNCTION}("${instanceId}", "${kernelId}", "${wsUrl}", ${stringOrNone(protocol)})`;
+        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._SEND_WEBSOCKET_FUNCTION}("${instanceId}", "${kernelId}", "${wsUrl}", '''${message}''')`;
+        const code = `await ${this._SERVER_VAR}.receive_ws_message("${instanceId}", "${kernelId}", "${wsUrl}", '''${message}''')`;
         return code;
     }
     async disposePythonServer() {
         await this.executeCode({
-            code: '__jupyterpack_tornado_dispose()'
+            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;
+}