jupyterpack 0.4.0 → 0.5.1

package/lib/pythonServer/streamlit/streamlitServer.js

@@ -1,10 +1,6 @@
 import { JupyterPackFramework } from '../../type';
 import { TornadoServer } from '../tornado/tornadoServer';
 export class StreamlitServer extends TornadoServer {
-    constructor() {
-        super(...arguments);
-        this._SERVER_VAR = '__jupyterpack_streamlit_server';
-    }
     async init(options) {
         const { instanceId, kernelClientId, entryPath } = options;
         if (!entryPath) {
@@ -21,18 +17,18 @@ export class StreamlitServer extends TornadoServer {
     patch_tornado()
     set_base_url_env("${baseURL}")
     `;
-        await this.executeCode({ code: patchCode });
+        await this.kernelExecutor.executeCode({ code: patchCode });
         const bootstrapCode = `
     from jupyterpack.streamlit import patch_streamlit
     patch_streamlit()
     `;
-        await this.executeCode({ code: bootstrapCode });
+        await this.kernelExecutor.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)
+      ${this._server_var} = StreamlitServer(__jupyterpack_tor_app, "${baseURL}", __jupyterpack_st_server)
       `;
-        await this.executeCode({ code: stCode });
+        await this.kernelExecutor.executeCode({ code: stCode });
     }
     async reloadPythonServer(options) {
         const { entryPath } = options;
@@ -40,11 +36,11 @@ export class StreamlitServer extends TornadoServer {
             return;
         }
         const reloadCode = `
-      ${this._SERVER_VAR}.dispose()
+      ${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)
+      ${this._server_var}.reload(__jupyterpack_tor_app, __jupyterpack_st_server)
       `;
-        await this.executeCode({
+        await this.kernelExecutor.executeCode({
             code: reloadCode
         }, true);
     }

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

@@ -1,34 +1,12 @@
-import { IDict } from '../../type';
-import { KernelExecutor } from '../kernelExecutor';
-export declare class TornadoServer extends KernelExecutor {
+import { BasePythonServer } from '../baseServer';
+export declare class TornadoServer extends BasePythonServer {
     init(options: {
         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>;
     reloadPythonServer(options: {
         entryPath?: string;
         initCode?: string;
     }): Promise<void>;
-    protected _SERVER_VAR: string;
 }

package/lib/pythonServer/tornado/tornadoServer.js

@@ -1,11 +1,6 @@
-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';
-    }
+import { BasePythonServer } from '../baseServer';
+export class TornadoServer extends BasePythonServer {
     async init(options) {
         await super.init(options);
         const { initCode, instanceId, kernelClientId } = options;
@@ -20,49 +15,29 @@ export class TornadoServer extends KernelExecutor {
     patch_tornado()
 
     `;
-        await this.executeCode({ code: bootstrapCode });
+        await this.kernelExecutor.executeCode({ code: bootstrapCode });
         if (initCode) {
             const initCodeWithUrl = initCode.replaceAll('{{base_url}}', baseURL);
-            await this.executeCode({ code: initCodeWithUrl });
+            await this.kernelExecutor.executeCode({ code: initCodeWithUrl });
             const loaderCode = `
       from jupyterpack.tornado import TornadoServer
-      ${this._SERVER_VAR} = TornadoServer(app, "${baseURL}")
+      ${this._server_var} = TornadoServer(app, "${baseURL}")
       `;
-            await this.executeCode({ code: loaderCode });
+            await this.kernelExecutor.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({
+            await this.kernelExecutor.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)
+      ${this._server_var}.dispose()
+      ${this._server_var}.reload(app)
       `;
-            await this.executeCode({ code: reloadCode }, true);
+            await this.kernelExecutor.executeCode({ code: reloadCode }, true);
         }
     }
 }

package/lib/swConnection/mainConnectionManager.d.ts

@@ -1,4 +1,4 @@
-import { IConnectionManager, IDict, IKernelExecutor } from '../type';
+import { IBasePythonServer, IConnectionManager, IDict } from '../type';
 /**
  * Manages connections between clients and kernel executors.
  * This class handles the registration of kernel executors and the generation of responses
@@ -10,7 +10,7 @@ import { IConnectionManager, IDict, IKernelExecutor } from '../type';
 export declare class ConnectionManager implements IConnectionManager {
     instanceId: string;
     constructor(instanceId: string);
-    registerConnection(kernelExecutor: IKernelExecutor): Promise<{
+    registerConnection(pythonServer: IBasePythonServer): Promise<{
         instanceId: string;
         kernelClientId: string;
     }>;
@@ -23,6 +23,6 @@ export declare class ConnectionManager implements IConnectionManager {
         params?: string;
     }): Promise<IDict | null>;
     private _initWsChannel;
-    private _kernelExecutors;
-    private _wsBroadcastChannel;
+    private _pythonServers;
+    private _wsBroadcastChannelMap;
 }

package/lib/swConnection/mainConnectionManager.js

@@ -1,4 +1,4 @@
-import { arrayBufferToBase64 } from '../tools';
+import { arrayBufferToBase64, stringToBase64 } from '../tools';
 import { UUID } from '@lumino/coreutils';
 /**
  * Manages connections between clients and kernel executors.
@@ -11,18 +11,20 @@ import { UUID } from '@lumino/coreutils';
 export class ConnectionManager {
     constructor(instanceId) {
         this.instanceId = instanceId;
-        this._kernelExecutors = new Map();
-        this._wsBroadcastChannel = new BroadcastChannel(`/jupyterpack/ws/${instanceId}`);
-        this._initWsChannel();
+        this._pythonServers = new Map();
+        this._wsBroadcastChannelMap = new Map();
     }
-    async registerConnection(kernelExecutor) {
+    async registerConnection(pythonServer) {
         const uuid = UUID.uuid4();
-        this._kernelExecutors.set(uuid, kernelExecutor);
+        this._pythonServers.set(uuid, pythonServer);
+        const wsbc = new BroadcastChannel(`/jupyterpack/ws/${this.instanceId}/${uuid}`);
+        this._initWsChannel(wsbc);
+        this._wsBroadcastChannelMap.set(`${this.instanceId}/${uuid}`, wsbc);
         return { instanceId: this.instanceId, kernelClientId: uuid };
     }
     async generateResponse(options) {
         const { urlPath, kernelClientId, method, params, requestBody, headers } = options;
-        const executor = this._kernelExecutors.get(kernelClientId);
+        const executor = this._pythonServers.get(kernelClientId);
         if (!executor) {
             return null;
         }
@@ -35,8 +37,8 @@ export class ConnectionManager {
         });
         return response;
     }
-    _initWsChannel() {
-        this._wsBroadcastChannel.onmessage = event => {
+    _initWsChannel(broadcastChannel) {
+        broadcastChannel.onmessage = event => {
             const rawData = event.data;
             let data;
             if (typeof rawData === 'string') {
@@ -46,9 +48,9 @@ export class ConnectionManager {
                 data = rawData;
             }
             const { action, dest, wsUrl, payload } = data;
-            const executor = this._kernelExecutors.get(dest);
+            const executor = this._pythonServers.get(dest);
             if (!executor) {
-                console.error('Missing kernel handle for message', data, dest, this._kernelExecutors);
+                console.error('Missing kernel handle for message', data, dest, this._pythonServers);
                 return;
             }
             switch (action) {
@@ -61,6 +63,14 @@ export class ConnectionManager {
                     });
                     break;
                 }
+                case 'close': {
+                    executor.closeWebsocket({
+                        instanceId: this.instanceId,
+                        kernelId: dest,
+                        wsUrl
+                    });
+                    break;
+                }
                 case 'send': {
                     let serializedData;
                     let isBinary;
@@ -70,7 +80,8 @@ export class ConnectionManager {
                         isBinary = true;
                     }
                     else if (typeof payload === 'string') {
-                        serializedData = payload;
+                        // convert string to base64 string to avoid encoding problem
+                        serializedData = stringToBase64(payload);
                         isBinary = false;
                     }
                     else {

package/lib/tools.d.ts

@@ -7,5 +7,6 @@ export declare function removePrefix(path: string, prefix: string): string;
 export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
 export declare function base64ToArrayBuffer(base64: string): Uint8Array;
 export declare function base64ToString(base64: string): string;
+export declare function stringToBase64(str: string): string;
 export declare function stringOrNone(content?: string): string;
 export declare function isBinaryContentType(contentType?: string): boolean;

package/lib/tools.js

@@ -44,6 +44,14 @@ export function base64ToString(base64) {
     const bytes = base64ToArrayBuffer(base64);
     return new TextDecoder('utf-8').decode(bytes);
 }
+export function stringToBase64(str) {
+    const bytes = new TextEncoder().encode(str);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return window.btoa(binary);
+}
 export function stringOrNone(content) {
     return content ? `"${content}"` : 'None';
 }

package/lib/type.d.ts

@@ -16,7 +16,9 @@ export declare enum JupyterPackFramework {
     REACT = "react",
     DASH = "dash",
     STREAMLIT = "streamlit",
-    TORNADO = "tornado"
+    TORNADO = "tornado",
+    SHINY = "shiny",
+    STARLETTE = "starlette"
 }
 export interface IJupyterPackFileFormat {
     entry: string;
@@ -38,6 +40,9 @@ export interface IKernelExecutorParams {
     requestBody?: ArrayBuffer;
 }
 export interface IKernelExecutor extends IDisposable {
+    executeCode(code: KernelMessage.IExecuteRequestMsg['content'], waitForResult?: boolean): Promise<string | null>;
+}
+export interface IBasePythonServer extends IDisposable {
     getResponse(options: IKernelExecutorParams): Promise<IDict>;
     openWebsocket(options: {
         instanceId: string;
@@ -45,13 +50,17 @@ export interface IKernelExecutor extends IDisposable {
         wsUrl: string;
         protocol?: string;
     }): Promise<void>;
+    closeWebsocket(options: {
+        instanceId: string;
+        kernelId: string;
+        wsUrl: string;
+    }): Promise<void>;
     sendWebsocketMessage(options: {
         instanceId: string;
         kernelId: string;
         wsUrl: string;
         message: string;
     }): Promise<void>;
-    executeCode(code: KernelMessage.IExecuteRequestMsg['content'], waitForResult?: boolean): Promise<string | null>;
     init(options: {
         entryPath?: string;
         initCode?: string;
@@ -72,7 +81,7 @@ export interface IKernelExecutor extends IDisposable {
     }): string;
 }
 export interface IConnectionManager {
-    registerConnection(kernelExecutor: IKernelExecutor): Promise<{
+    registerConnection(kernelExecutor: IBasePythonServer): Promise<{
         instanceId: string;
         kernelClientId: string;
     }>;

package/lib/type.js

@@ -4,6 +4,8 @@ export var JupyterPackFramework;
     JupyterPackFramework["DASH"] = "dash";
     JupyterPackFramework["STREAMLIT"] = "streamlit";
     JupyterPackFramework["TORNADO"] = "tornado";
+    JupyterPackFramework["SHINY"] = "shiny";
+    JupyterPackFramework["STARLETTE"] = "starlette";
 })(JupyterPackFramework || (JupyterPackFramework = {}));
 export var MessageAction;
 (function (MessageAction) {

package/lib/websocket/websocket.js

@@ -36,7 +36,7 @@
         }
         return data;
     };
-    const bcWsChannel = new BroadcastChannel(`/jupyterpack/ws/${instanceId}`);
+    const bcWsChannel = new BroadcastChannel(`/jupyterpack/ws/${instanceId}/${kernelClientId}`);
     class BroadcastChannelWebSocket {
         constructor(url, protocols) {
             this.onclose = () => {
@@ -128,6 +128,10 @@
                 cb();
             }
             this._eventHandlers['close'] = [];
+            sendTypedMessage({
+                action: 'close',
+                wsUrl: this.url
+            });
             bcWsChannel.removeEventListener('message', this._bcMessageHandler);
             this.readyState = this.CLOSED;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterpack",
-    "version": "0.4.0",
+    "version": "0.5.1",
     "description": "A JupyterLab extension for serving web app.",
     "keywords": [
         "jupyter",

package/src/document/widgetFactory.ts

@@ -54,7 +54,9 @@ export class JupyterPackWidgetFactory extends ABCWidgetFactory<JupyterPackDocWid
         }
         case JupyterPackFramework.DASH:
         case JupyterPackFramework.STREAMLIT:
-        case JupyterPackFramework.TORNADO: {
+        case JupyterPackFramework.TORNADO:
+        case JupyterPackFramework.STARLETTE:
+        case JupyterPackFramework.SHINY: {
           const model = new PythonWidgetModel({
             jpackModel,
             context,

package/src/pythonServer/baseServer.ts

@@ -0,0 +1,245 @@
+import { KernelExecutor } from './kernelExecutor';
+import websocketPatch from '../websocket/websocket.js?raw';
+import {
+  IDict,
+  IBasePythonServer,
+  IKernelExecutor,
+  JupyterPackFramework
+} from '../type';
+import { PageConfig, URLExt } from '@jupyterlab/coreutils';
+import {
+  arrayBufferToBase64,
+  base64ToArrayBuffer,
+  base64ToString,
+  isBinaryContentType,
+  stringOrNone
+} from '../tools';
+
+export abstract class BasePythonServer implements IBasePythonServer {
+  constructor(options: KernelExecutor.IOptions) {
+    this._kernelExecutor = new KernelExecutor(options);
+    this._wsPatch = websocketPatch.replaceAll('"use strict";', '');
+  }
+
+  abstract reloadPythonServer(options: {
+    entryPath?: string;
+    initCode?: string;
+  }): Promise<void>;
+
+  get isDisposed(): boolean {
+    return this._isDisposed;
+  }
+
+  get kernelExecutor() {
+    return this._kernelExecutor;
+  }
+
+  dispose(): void {
+    if (this._isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+    this.disposePythonServer()
+      .then(() => {
+        this._kernelExecutor.dispose();
+      })
+      .catch(console.error);
+  }
+  async init(options: {
+    entryPath?: string;
+    initCode?: string;
+    instanceId: string;
+    kernelClientId: string;
+  }): Promise<void> {
+    const patchCode = `
+    from jupyterpack.common import patch_all
+    patch_all()
+    `;
+    await this._kernelExecutor.executeCode({ code: patchCode });
+  }
+
+  async disposePythonServer(): Promise<void> {
+    await this.kernelExecutor.executeCode({
+      code: `${this._server_var}.dispose()`
+    });
+    for (const element of this._openedWebsockets) {
+      await this.closeWebsocket(element);
+    }
+  }
+
+  getResponseFunctionFactory(options: {
+    urlPath: string;
+    method: string;
+    headers: IDict;
+    params?: string;
+    content?: string;
+  }) {
+    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: {
+    instanceId: string;
+    kernelId: string;
+    wsUrl: string;
+    protocol?: string;
+  }): string {
+    const { instanceId, kernelId, wsUrl, protocol } = options;
+    const code = `await ${this._server_var}.open_ws("${instanceId}", "${kernelId}", "${wsUrl}", ${stringOrNone(protocol)})`;
+    return code;
+  }
+
+  closeWebsocketFunctionFactory(options: {
+    instanceId: string;
+    kernelId: string;
+    wsUrl: string;
+  }): string {
+    const { instanceId, kernelId, wsUrl } = options;
+    const code = `await ${this._server_var}.close_ws("${instanceId}", "${kernelId}", "${wsUrl}")`;
+    return code;
+  }
+
+  sendWebsocketMessageFunctionFactory(options: {
+    instanceId: string;
+    kernelId: string;
+    wsUrl: string;
+    message: string;
+  }): string {
+    const { instanceId, kernelId, wsUrl, message } = options;
+    const code = `await ${this._server_var}.receive_ws_message("${instanceId}", "${kernelId}", "${wsUrl}", '''${message}''')`;
+    return code;
+  }
+
+  async openWebsocket(options: {
+    instanceId: string;
+    kernelId: string;
+    wsUrl: string;
+    protocol?: string;
+  }): Promise<void> {
+    const code = this.openWebsocketFunctionFactory(options);
+    if (code) {
+      try {
+        await this._kernelExecutor.executeCode({ code });
+        this._openedWebsockets.push(options);
+      } catch (e) {
+        console.error('Failed to open websocket', e);
+      }
+    } else {
+      throw new Error('Missing websocket open code');
+    }
+  }
+
+  async closeWebsocket(options: {
+    instanceId: string;
+    kernelId: string;
+    wsUrl: string;
+  }): Promise<void> {
+    const code = this.closeWebsocketFunctionFactory(options);
+    if (code) {
+      await this._kernelExecutor.executeCode({ code });
+    } else {
+      throw new Error('Missing websocket close code');
+    }
+  }
+
+  async sendWebsocketMessage(options: {
+    instanceId: string;
+    kernelId: string;
+    wsUrl: string;
+    message: string;
+  }): Promise<void> {
+    const code = this.sendWebsocketMessageFunctionFactory(options);
+    if (code) {
+      await this._kernelExecutor.executeCode({ code });
+    } else {
+      throw new Error('Missing websocket send 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._kernelExecutor.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().includes('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;
+  }
+
+  protected buildBaseURL(options: {
+    instanceId: string;
+    kernelClientId: string;
+    framework: JupyterPackFramework;
+  }) {
+    const { instanceId, kernelClientId, framework } = options;
+    const fullLabextensionsUrl = PageConfig.getOption('fullLabextensionsUrl');
+
+    const baseURL = URLExt.join(
+      fullLabextensionsUrl,
+      'jupyterpack/static',
+      instanceId,
+      framework,
+      kernelClientId,
+      '/'
+    );
+    this._baseUrl = baseURL;
+
+    return baseURL;
+  }
+
+  protected _baseUrl: string | undefined;
+  protected readonly _openedWebsockets: {
+    instanceId: string;
+    kernelId: string;
+    wsUrl: string;
+  }[] = [];
+  protected readonly _server_var = '__jupyterpack_python_server';
+
+  private _kernelExecutor: IKernelExecutor;
+  private _isDisposed: boolean = false;
+  private _wsPatch: string;
+}