jupyterpack 0.4.0 → 0.5.2

package/lib/pythonServer/shiny/deps.d.ts

@@ -0,0 +1,2 @@
+import { IDependencies } from '../../type';
+export declare const DEPENDENCIES: IDependencies;

package/lib/pythonServer/shiny/deps.js

@@ -0,0 +1,4 @@
+export const DEPENDENCIES = {
+    mamba: [],
+    pip: ['shiny', 'shinychat']
+};

package/lib/pythonServer/shiny/shinyServer.d.ts

@@ -0,0 +1,10 @@
+import { IPythonServerInitOptions } from '../../type';
+import { BasePythonServer } from '../baseServer';
+export declare class ShinyServer extends BasePythonServer {
+    init(options: IPythonServerInitOptions): Promise<void>;
+    disposePythonServer(): Promise<void>;
+    reloadPythonServer(options: {
+        entryPath?: string;
+        initCode?: string;
+    }): Promise<void>;
+}

package/lib/pythonServer/shiny/shinyServer.js

@@ -0,0 +1,54 @@
+import { JupyterPackFramework } from '../../type';
+import { BasePythonServer } from '../baseServer';
+import { DEPENDENCIES } from './deps';
+export class ShinyServer extends BasePythonServer {
+    async init(options) {
+        const mergedOptions = {
+            ...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() {
+        await this.kernelExecutor.executeCode({
+            code: `${this._server_var}.dispose()`
+        });
+        for (const element of this._openedWebsockets) {
+            await this.closeWebsocket(element);
+        }
+    }
+    async reloadPythonServer(options) {
+        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/lib/pythonServer/starlette/starletteServer.d.ts

@@ -0,0 +1,13 @@
+import { BasePythonServer } from '../baseServer';
+export declare class StarletteServer extends BasePythonServer {
+    init(options: {
+        initCode?: string;
+        instanceId: string;
+        kernelClientId: string;
+    }): Promise<void>;
+    disposePythonServer(): Promise<void>;
+    reloadPythonServer(options: {
+        entryPath?: string;
+        initCode?: string;
+    }): Promise<void>;
+}

package/lib/pythonServer/starlette/starletteServer.js

@@ -0,0 +1,49 @@
+import { JupyterPackFramework } from '../../type';
+import { BasePythonServer } from '../baseServer';
+export class StarletteServer extends BasePythonServer {
+    async init(options) {
+        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() {
+        await this.kernelExecutor.executeCode({
+            code: `${this._server_var}.dispose()`
+        });
+        for (const element of this._openedWebsockets) {
+            await this.closeWebsocket(element);
+        }
+    }
+    async reloadPythonServer(options) {
+        var _a;
+        const { initCode } = options;
+        if (initCode) {
+            await this.kernelExecutor.executeCode({
+                code: initCode.replaceAll('{{base_url}}', (_a = this._baseUrl) !== null && _a !== void 0 ? _a : '')
+            });
+            const reloadCode = `
+      await ${this._server_var}.dispose()
+      ${this._server_var}.reload(app)
+      `;
+            await this.kernelExecutor.executeCode({ code: reloadCode }, true);
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+import { IDependencies } from '../../type';
+export declare const DEPENDENCIES: IDependencies;

package/lib/pythonServer/streamlit/deps.js

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

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

@@ -1,14 +1,9 @@
-import { TornadoServer } from '../tornado/tornadoServer';
-export declare class StreamlitServer extends TornadoServer {
-    init(options: {
-        entryPath?: string;
-        initCode?: string;
-        instanceId: string;
-        kernelClientId: string;
-    }): Promise<void>;
+import { IPythonServerInitOptions } from '../../type';
+import { BasePythonServer } from '../baseServer';
+export declare class StreamlitServer extends BasePythonServer {
+    init(options: IPythonServerInitOptions): Promise<void>;
     reloadPythonServer(options: {
         entryPath?: string;
         initCode?: string;
     }): Promise<void>;
-    protected _SERVER_VAR: string;
 }

package/lib/pythonServer/streamlit/streamlitServer.js

@@ -1,11 +1,13 @@
 import { JupyterPackFramework } from '../../type';
-import { TornadoServer } from '../tornado/tornadoServer';
-export class StreamlitServer extends TornadoServer {
-    constructor() {
-        super(...arguments);
-        this._SERVER_VAR = '__jupyterpack_streamlit_server';
-    }
+import { BasePythonServer } from '../baseServer';
+import { DEPENDENCIES } from './deps';
+export class StreamlitServer extends BasePythonServer {
     async init(options) {
+        const mergedOptions = {
+            ...options,
+            dependencies: this.mergeDependencies(options.dependencies, DEPENDENCIES)
+        };
+        await super.init(mergedOptions);
         const { instanceId, kernelClientId, entryPath } = options;
         if (!entryPath) {
             throw new Error('Missing streamlit entry path, please check your SPK file');
@@ -16,23 +18,22 @@ export class StreamlitServer extends TornadoServer {
             framework: JupyterPackFramework.STREAMLIT
         });
         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) {
         const { entryPath } = options;
@@ -40,11 +41,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/pythonWidget/pythonWidgetModel.js

@@ -109,6 +109,8 @@ export class PythonWidgetModel {
         await executor.init({
             initCode: entryContent.content,
             entryPath: spkContent.entry,
+            dependencies: spkContent.dependencies,
+            disableDependencies: spkContent.disableDependencies,
             ...data
         });
         const finish = new PromiseDelegate();

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;
@@ -26,6 +28,8 @@ export interface IJupyterPackFileFormat {
         autoreload?: boolean;
     };
     rootUrl?: string;
+    dependencies?: IDependencies;
+    disableDependencies?: boolean;
 }
 export declare enum MessageAction {
     INIT = "INIT"
@@ -38,6 +42,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,19 +52,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;
@@ -72,7 +78,7 @@ export interface IKernelExecutor extends IDisposable {
     }): string;
 }
 export interface IConnectionManager {
-    registerConnection(kernelExecutor: IKernelExecutor): Promise<{
+    registerConnection(kernelExecutor: IBasePythonServer): Promise<{
         instanceId: string;
         kernelClientId: string;
     }>;
@@ -97,3 +103,15 @@ export interface IPythonWidgetModel extends IDisposable {
         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/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.2",
     "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,