jupyterpack 0.4.0 → 0.5.2

package/src/pythonServer/baseServer.ts

@@ -0,0 +1,285 @@
+import { PageConfig, URLExt } from '@jupyterlab/coreutils';
+
+import {
+  arrayBufferToBase64,
+  base64ToArrayBuffer,
+  base64ToString,
+  isBinaryContentType,
+  stringOrNone
+} from '../tools';
+import {
+  IBasePythonServer,
+  IDependencies,
+  IDict,
+  IKernelExecutor,
+  IPythonServerInitOptions,
+  JupyterPackFramework
+} from '../type';
+import websocketPatch from '../websocket/websocket.js?raw';
+import { KernelExecutor } from './kernelExecutor';
+
+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: IPythonServerInitOptions): Promise<void> {
+    const patchCode = `
+    from jupyterpack.common import patch_all
+    patch_all()
+    `;
+    await this._kernelExecutor.executeCode({ code: patchCode });
+    if (!options.disableDependencies) {
+      const { dependencies } = options;
+      if (dependencies?.mamba) {
+        const mambaDeps = `
+      %mamba install ${dependencies.mamba.join(' ')}
+      True
+      `;
+        await this.kernelExecutor.executeCode(
+          {
+            code: mambaDeps
+          },
+          true
+        );
+      }
+      if (dependencies?.pip) {
+        const pipDeps = `
+        %pip install ${dependencies.pip.join(' ')}
+        True
+        `;
+        await this.kernelExecutor.executeCode(
+          {
+            code: pipDeps
+          },
+          true
+        );
+      }
+    }
+  }
+
+  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 mergeDependencies(
+    spkDeps?: IDependencies,
+    defaultDeps?: IDependencies
+  ): IDependencies | undefined {
+    if (!spkDeps) {
+      return defaultDeps;
+    }
+    if (!defaultDeps) {
+      return spkDeps;
+    }
+    const merged: IDependencies = {};
+    merged.mamba = [...(spkDeps.mamba ?? []), ...(defaultDeps.mamba ?? [])];
+    merged.pip = [...(spkDeps.pip ?? []), ...(defaultDeps.pip ?? [])];
+    return merged;
+  }
+
+  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;
+}

package/src/pythonServer/dash/dashServer.ts

@@ -1,14 +1,15 @@
-import { stringOrNone } from '../../tools';
-import { IDict, JupyterPackFramework } from '../../type';
-import { KernelExecutor } from '../kernelExecutor';
+import { IPythonServerInitOptions, JupyterPackFramework } from '../../type';
+import { BasePythonServer } from '../baseServer';
+import { DEPENDENCIES } from './deps';
+
+export class DashServer extends BasePythonServer {
+  async init(options: IPythonServerInitOptions) {
+    const mergedOptions: IPythonServerInitOptions = {
+      ...options,
+      dependencies: this.mergeDependencies(options.dependencies, DEPENDENCIES)
+    };
+    await super.init(mergedOptions);
 
-export class DashServer extends KernelExecutor {
-  async init(options: {
-    initCode?: string;
-    instanceId: string;
-    kernelClientId: string;
-  }) {
-    await super.init(options);
     const { initCode, instanceId, kernelClientId } = options;
 
     const baseURL = this.buildBaseURL({
@@ -16,36 +17,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 +39,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/dash/deps.ts

@@ -0,0 +1,6 @@
+import { IDependencies } from '../../type';
+
+export const DEPENDENCIES: IDependencies = {
+  mamba: ['dash', 'werkzeug>=2.2,<3.0'],
+  pip: []
+};

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

@@ -0,0 +1,6 @@
+import { IDependencies } from '../../type';
+
+export const DEPENDENCIES: IDependencies = {
+  mamba: [],
+  pip: ['shiny', 'shinychat']
+};

package/src/pythonServer/shiny/shinyServer.ts

@@ -0,0 +1,63 @@
+import { IPythonServerInitOptions, JupyterPackFramework } from '../../type';
+import { BasePythonServer } from '../baseServer';
+import { DEPENDENCIES } from './deps';
+
+export class ShinyServer extends BasePythonServer {
+  async init(options: IPythonServerInitOptions) {
+    const mergedOptions: IPythonServerInitOptions = {
+      ...options,
+      dependencies: this.mergeDependencies(options.dependencies, DEPENDENCIES)
+    };
+    await super.init(mergedOptions);
+
+    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);
+    }
+  }
+}