jupyterpack 0.4.0 → 0.5.2

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/deps.ts

@@ -0,0 +1,12 @@
+import { IDependencies } from '../../type';
+
+export const DEPENDENCIES: IDependencies = {
+  mamba: [
+    'pyarrow',
+    'altair',
+    'blinker>=1.5.0,<2',
+    'cachetools>=4.0,<7',
+    'protobuf'
+  ],
+  pip: ['streamlit==1.50.0']
+};

package/src/pythonServer/streamlit/streamlitServer.ts

@@ -1,13 +1,15 @@
-import { JupyterPackFramework } from '../../type';
-import { TornadoServer } from '../tornado/tornadoServer';
+import { IPythonServerInitOptions, JupyterPackFramework } from '../../type';
+import { BasePythonServer } from '../baseServer';
+import { DEPENDENCIES } from './deps';
+
+export class StreamlitServer extends BasePythonServer {
+  async init(options: IPythonServerInitOptions) {
+    const mergedOptions: IPythonServerInitOptions = {
+      ...options,
+      dependencies: this.mergeDependencies(options.dependencies, DEPENDENCIES)
+    };
+    await super.init(mergedOptions);
 
-export class StreamlitServer extends TornadoServer {
-  async init(options: {
-    entryPath?: string;
-    initCode?: string;
-    instanceId: string;
-    kernelClientId: string;
-  }) {
     const { instanceId, kernelClientId, entryPath } = options;
     if (!entryPath) {
       throw new Error(
@@ -21,25 +23,24 @@ export class StreamlitServer extends TornadoServer {
     });
 
     const patchCode = `
-    from jupyterpack.common import set_base_url_env, patch_tornado, patch_all
-    patch_all()
+    from jupyterpack.common import set_base_url_env, patch_tornado
     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 +52,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';
@@ -135,9 +135,12 @@ export class PythonWidgetModel implements IPythonWidgetModel {
       sessionConnection: this._sessionConnection
     }));
     const data = await this._connectionManager.registerConnection(executor);
+
     await executor.init({
       initCode: entryContent.content,
       entryPath: spkContent.entry,
+      dependencies: spkContent.dependencies,
+      disableDependencies: spkContent.disableDependencies,
       ...data
     });
     const finish = new PromiseDelegate<void>();
@@ -203,7 +206,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';
 }

package/src/type.ts

@@ -26,7 +26,9 @@ export enum JupyterPackFramework {
   REACT = 'react',
   DASH = 'dash',
   STREAMLIT = 'streamlit',
-  TORNADO = 'tornado'
+  TORNADO = 'tornado',
+  SHINY = 'shiny',
+  STARLETTE = 'starlette'
 }
 export interface IJupyterPackFileFormat {
   entry: string;
@@ -36,6 +38,8 @@ export interface IJupyterPackFileFormat {
     autoreload?: boolean;
   };
   rootUrl?: string;
+  dependencies?: IDependencies;
+  disableDependencies?: boolean;
 }
 
 export enum MessageAction {
@@ -49,7 +53,15 @@ export interface IKernelExecutorParams {
   params?: string;
   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;
@@ -57,22 +69,18 @@ export interface IKernelExecutor extends IDisposable {
     wsUrl: string;
     protocol?: string;
   }): Promise<void>;
-  sendWebsocketMessage(options: {
+  closeWebsocket(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;
+  sendWebsocketMessage(options: {
     instanceId: string;
-    kernelClientId: string;
+    kernelId: string;
+    wsUrl: string;
+    message: string;
   }): Promise<void>;
+  init(options: IPythonServerInitOptions): Promise<void>;
   disposePythonServer(): Promise<void>;
   reloadPythonServer(options: {
     entryPath?: string;
@@ -89,7 +97,7 @@ export interface IKernelExecutor extends IDisposable {
 
 export interface IConnectionManager {
   registerConnection(
-    kernelExecutor: IKernelExecutor
+    kernelExecutor: IBasePythonServer
   ): Promise<{ instanceId: string; kernelClientId: string }>;
   generateResponse(
     option: { kernelClientId: string } & IKernelExecutorParams
@@ -114,3 +122,17 @@ export interface IPythonWidgetModel extends IDisposable {
     | { success: false; error: string }
   >;
 }
+
+export interface IDependencies {
+  mamba?: string[];
+  pip?: string[];
+}
+
+export interface IPythonServerInitOptions {
+  entryPath?: string;
+  initCode?: string;
+  instanceId: string;
+  kernelClientId: string;
+  dependencies?: IDependencies;
+  disableDependencies?: boolean;
+}

package/src/websocket/websocket.ts

@@ -59,7 +59,9 @@
     }
     return data;
   };
-  const bcWsChannel = new BroadcastChannel(`/jupyterpack/ws/${instanceId}`);
+  const bcWsChannel = new BroadcastChannel(
+    `/jupyterpack/ws/${instanceId}/${kernelClientId}`
+  );
 
   class BroadcastChannelWebSocket implements WebSocket {
     constructor(url: string | URL, protocols?: string | string[]) {
@@ -109,6 +111,10 @@
         cb();
       }
       this._eventHandlers['close'] = [];
+      sendTypedMessage({
+        action: 'close',
+        wsUrl: this.url
+      });
       bcWsChannel.removeEventListener('message', this._bcMessageHandler);
 
       this.readyState = this.CLOSED;
@@ -168,10 +174,12 @@
       } else {
         data = rawData;
       }
+
       const { action, dest, wsUrl, payload } = data;
       if (dest !== kernelClientId || wsUrl !== this.url) {
         return;
       }
+
       switch (action) {
         case 'connected': {
           this.readyState = this.OPEN;