jupyterpack 0.4.0 → 0.5.1

package/src/pythonServer/dash/dashServer.ts

@@ -1,8 +1,7 @@
-import { stringOrNone } from '../../tools';
-import { IDict, JupyterPackFramework } from '../../type';
-import { KernelExecutor } from '../kernelExecutor';
+import { JupyterPackFramework } from '../../type';
+import { BasePythonServer } from '../baseServer';
 
-export class DashServer extends KernelExecutor {
+export class DashServer extends BasePythonServer {
   async init(options: {
     initCode?: string;
     instanceId: string;
@@ -16,36 +15,20 @@ export class DashServer extends KernelExecutor {
       kernelClientId,
       framework: JupyterPackFramework.DASH
     });
-    await this.executeCode({
+    await this.kernelExecutor.executeCode({
       code: `
       import os
       os.environ["DASH_URL_BASE_PATHNAME"] = "${baseURL}"
       `
     });
     if (initCode) {
-      await this.executeCode({ code: initCode });
+      await this.kernelExecutor.executeCode({ code: initCode });
     }
     const loaderCode = `
       from jupyterpack.dash import DashServer
-      ${this._DASH_SERVER_VAR} = DashServer(app, "${baseURL}")
+      ${this._server_var} = DashServer(app, "${baseURL}")
       `;
-    await this.executeCode({ code: loaderCode });
-  }
-
-  getResponseFunctionFactory(options: {
-    urlPath: string;
-    method: string;
-    headers: IDict;
-    params?: string;
-    content?: string;
-  }) {
-    const { method, urlPath, headers, params, content } = options;
-    const code = `${this._DASH_SERVER_VAR}.get_response("${method}", "${urlPath}", headers=${JSON.stringify(headers)} , content=${stringOrNone(content)}, params=${stringOrNone(params)})`;
-    return code;
-  }
-
-  async disposePythonServer(): Promise<void> {
-    await this.executeCode({ code: `${this._DASH_SERVER_VAR}.dispose()` });
+    await this.kernelExecutor.executeCode({ code: loaderCode });
   }
 
   async reloadPythonServer(options: {
@@ -54,13 +37,11 @@ export class DashServer extends KernelExecutor {
   }): Promise<void> {
     const { initCode } = options;
     if (initCode) {
-      await this.executeCode({ code: initCode });
+      await this.kernelExecutor.executeCode({ code: initCode });
     }
-    await this.executeCode(
-      { code: `${this._DASH_SERVER_VAR}.reload(app)` },
+    await this.kernelExecutor.executeCode(
+      { code: `${this._server_var}.reload(app)` },
       true
     );
   }
-
-  private _DASH_SERVER_VAR = '__jupyterpack_dash_server';
 }

package/src/pythonServer/index.ts

@@ -1,18 +1,22 @@
-import { IKernelExecutor, JupyterPackFramework } from '../type';
+import { IBasePythonServer, JupyterPackFramework } from '../type';
 import { DashServer } from './dash/dashServer';
 import { KernelExecutor } from './kernelExecutor';
+import { ShinyServer } from './shiny/shinyServer';
+import { StarletteServer } from './starlette/starletteServer';
 import { StreamlitServer } from './streamlit/streamlitServer';
 import { TornadoServer } from './tornado/tornadoServer';
 
-type KernelExecutorConstructor = new (
+type BasePythonServerConstructor = new (
   options: KernelExecutor.IOptions
-) => IKernelExecutor;
+) => IBasePythonServer;
 
 export const PYTHON_SERVER = new Map<
   JupyterPackFramework,
-  KernelExecutorConstructor
+  BasePythonServerConstructor
 >([
   [JupyterPackFramework.DASH, DashServer],
   [JupyterPackFramework.STREAMLIT, StreamlitServer],
-  [JupyterPackFramework.TORNADO, TornadoServer]
+  [JupyterPackFramework.TORNADO, TornadoServer],
+  [JupyterPackFramework.SHINY, ShinyServer],
+  [JupyterPackFramework.STARLETTE, StarletteServer]
 ]);

package/src/pythonServer/kernelExecutor.ts

@@ -1,146 +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';
 
-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 reloadPythonServer(options: {
-    entryPath?: string;
-    initCode?: string;
-  }): 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> {
-    const patchCode = `
-    from jupyterpack.common import patch_all
-    patch_all()
-    `;
-    await this.executeCode({ code: patchCode });
-  }
-
-  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
@@ -208,32 +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 fullLabextensionsUrl = PageConfig.getOption('fullLabextensionsUrl');
-
-    const baseURL = URLExt.join(
-      fullLabextensionsUrl,
-      'jupyterpack/static',
-      instanceId,
-      framework,
-      kernelClientId,
-      '/'
-    );
-    this._baseUrl = baseURL;
-
-    return baseURL;
-  }
-
-  protected _baseUrl: string | undefined;
-
   private _isDisposed: boolean = false;
   private _sessionConnection: Session.ISessionConnection;
-  private _wsPatch: string;
 }
 
 export namespace KernelExecutor {

package/src/pythonServer/shiny/shinyServer.ts

@@ -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

@@ -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

@@ -26,20 +26,20 @@ 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: {
@@ -51,17 +51,15 @@ 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
     );
   }
-
-  protected _SERVER_VAR = '__jupyterpack_streamlit_server';
 }

package/src/pythonServer/tornado/tornadoServer.ts

@@ -1,8 +1,7 @@
-import { stringOrNone } from '../../tools';
-import { IDict, JupyterPackFramework } from '../../type';
-import { KernelExecutor } from '../kernelExecutor';
+import { JupyterPackFramework } from '../../type';
+import { BasePythonServer } from '../baseServer';
 
-export class TornadoServer extends KernelExecutor {
+export class TornadoServer extends BasePythonServer {
   async init(options: {
     initCode?: string;
     instanceId: string;
@@ -22,76 +21,33 @@ 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: {
-    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;
-  }
-
-  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 disposePythonServer(): Promise<void> {
-    await this.executeCode({
-      code: `${this._SERVER_VAR}.dispose()`
-    });
-  }
-
   async reloadPythonServer(options: {
     entryPath?: string;
     initCode?: string;
   }): Promise<void> {
     const { initCode } = options;
     if (initCode) {
-      await this.executeCode({
+      await this.kernelExecutor.executeCode({
         code: initCode.replaceAll('{{base_url}}', this._baseUrl ?? '')
       });
       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);
     }
   }
-
-  protected _SERVER_VAR = '__jupyterpack_tornado_server';
 }

package/src/pythonWidget/pythonWidgetModel.ts

@@ -11,9 +11,9 @@ import { PromiseDelegate } from '@lumino/coreutils';
 import { PYTHON_SERVER } from '../pythonServer';
 import { Signal } from '@lumino/signaling';
 import {
+  IBasePythonServer,
   IConnectionManager,
   IJupyterPackFileFormat,
-  IKernelExecutor,
   IPythonWidgetModel,
   JupyterPackFramework
 } from '../type';
@@ -203,7 +203,7 @@ export class PythonWidgetModel implements IPythonWidgetModel {
   private _connectionManager: IConnectionManager;
   private _contentsManager: Contents.IManager;
   private _jpackModel: IJupyterPackFileFormat;
-  private _executor?: IKernelExecutor;
+  private _executor?: IBasePythonServer;
   private _localPath: string;
 
   private _serverReloaded: Signal<IPythonWidgetModel, void> = new Signal<

package/src/swConnection/mainConnectionManager.ts

@@ -1,9 +1,9 @@
-import { arrayBufferToBase64 } from '../tools';
+import { arrayBufferToBase64, stringToBase64 } from '../tools';
 import {
+  IBasePythonServer,
   IBroadcastMessage,
   IConnectionManager,
-  IDict,
-  IKernelExecutor
+  IDict
 } from '../type';
 import { UUID } from '@lumino/coreutils';
 
@@ -16,20 +16,19 @@ import { UUID } from '@lumino/coreutils';
  * It's running on the main thread
  */
 export class ConnectionManager implements IConnectionManager {
-  constructor(public instanceId: string) {
-    this._wsBroadcastChannel = new BroadcastChannel(
-      `/jupyterpack/ws/${instanceId}`
-    );
-    this._initWsChannel();
-  }
+  constructor(public instanceId: string) {}
 
   async registerConnection(
-    kernelExecutor: IKernelExecutor
+    pythonServer: IBasePythonServer
   ): Promise<{ instanceId: string; kernelClientId: string }> {
     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 };
   }
 
@@ -43,7 +42,7 @@ export class ConnectionManager implements IConnectionManager {
   }): Promise<IDict | null> {
     const { urlPath, kernelClientId, method, params, requestBody, headers } =
       options;
-    const executor = this._kernelExecutors.get(kernelClientId);
+    const executor = this._pythonServers.get(kernelClientId);
     if (!executor) {
       return null;
     }
@@ -57,8 +56,8 @@ export class ConnectionManager implements IConnectionManager {
     });
     return response;
   }
-  private _initWsChannel() {
-    this._wsBroadcastChannel.onmessage = event => {
+  private _initWsChannel(broadcastChannel: BroadcastChannel) {
+    broadcastChannel.onmessage = event => {
       const rawData = event.data;
       let data: IBroadcastMessage;
       if (typeof rawData === 'string') {
@@ -68,13 +67,13 @@ export class ConnectionManager implements IConnectionManager {
       }
 
       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
+          this._pythonServers
         );
         return;
       }
@@ -89,6 +88,14 @@ export class ConnectionManager implements IConnectionManager {
           });
           break;
         }
+        case 'close': {
+          executor.closeWebsocket({
+            instanceId: this.instanceId,
+            kernelId: dest,
+            wsUrl
+          });
+          break;
+        }
         case 'send': {
           let serializedData: string;
           let isBinary: boolean;
@@ -97,7 +104,8 @@ export class ConnectionManager implements IConnectionManager {
             serializedData = arrayBufferToBase64(payload as any);
             isBinary = true;
           } else if (typeof payload === 'string') {
-            serializedData = payload;
+            // convert string to base64 string to avoid encoding problem
+            serializedData = stringToBase64(payload);
             isBinary = false;
           } else {
             console.error('Unknown message type', payload);
@@ -116,6 +124,6 @@ export class ConnectionManager implements IConnectionManager {
       }
     };
   }
-  private _kernelExecutors = new Map<string, IKernelExecutor>();
-  private _wsBroadcastChannel: BroadcastChannel;
+  private _pythonServers = new Map<string, IBasePythonServer>();
+  private _wsBroadcastChannelMap: Map<string, BroadcastChannel> = new Map();
 }

package/src/tools.ts

@@ -53,6 +53,15 @@ export function base64ToString(base64: string): string {
   return new TextDecoder('utf-8').decode(bytes);
 }
 
+export function stringToBase64(str: string): string {
+  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?: string) {
   return content ? `"${content}"` : 'None';
 }