jupyterpack 0.2.1 → 0.3.0

package/src/pythonWidget/pythonWidgetModel.ts

@@ -1,15 +1,21 @@
+import { PathExt } from '@jupyterlab/coreutils';
 import { DocumentRegistry } from '@jupyterlab/docregistry';
-import { IDisposable } from '@lumino/disposable';
 import {
-  ServiceManager,
-  Session,
+  Contents,
   Kernel,
-  Contents
+  ServiceManager,
+  Session
 } from '@jupyterlab/services';
 import { PromiseDelegate } from '@lumino/coreutils';
-import { IConnectionManager, IJupyterPackFileFormat } from '../type';
-import { KernelExecutor } from './kernelExecutor';
-import { PathExt } from '@jupyterlab/coreutils';
+import { IDisposable } from '@lumino/disposable';
+
+import { PYTHON_SERVER } from '../pythonServer';
+import {
+  IConnectionManager,
+  IJupyterPackFileFormat,
+  IKernelExecutor,
+  JupyterPackFramework
+} from '../type';
 
 export class PythonWidgetModel implements IDisposable {
   constructor(options: PythonWidgetModel.IOptions) {
@@ -17,6 +23,7 @@ export class PythonWidgetModel implements IDisposable {
     this._manager = options.manager;
     this._connectionManager = options.connectionManager;
     this._contentsManager = options.contentsManager;
+    this._jpackModel = options.jpackModel;
   }
 
   get isDisposed(): boolean {
@@ -25,19 +32,27 @@ export class PythonWidgetModel implements IDisposable {
   get connectionManager(): IConnectionManager {
     return this._connectionManager;
   }
-  async initialize(): Promise<{
-    instanceId: string;
-    kernelClientId: string;
-  } | null> {
+  async initialize(): Promise<
+    | {
+        success: true;
+        instanceId: string;
+        kernelClientId: string;
+        rootUrl: string;
+        framework: JupyterPackFramework;
+      }
+    | { success: false; error: string }
+  > {
     if (this._kernelStarted) {
-      return null;
+      return {
+        success: false,
+        error: 'Server is called twice'
+      };
     }
     const filePath = this._context.localPath;
-    const spkContent =
-      this._context.model.toJSON() as any as IJupyterPackFileFormat;
+    const spkContent = this._jpackModel;
 
     const entryPath = PathExt.join(PathExt.dirname(filePath), spkContent.entry);
-
+    const rootUrl = spkContent.rootUrl ?? '/';
     const entryContent = await this._contentsManager.get(entryPath, {
       content: true,
       format: 'text'
@@ -47,7 +62,10 @@ export class PythonWidgetModel implements IDisposable {
     await this._manager.kernelspecs.ready;
     const specs = this._manager.kernelspecs.specs;
     if (!specs) {
-      return null;
+      return {
+        success: false,
+        error: 'Missing kernel spec'
+      };
     }
     const { kernelspecs } = specs;
     let kernelName = Object.keys(kernelspecs)[0];
@@ -63,12 +81,21 @@ export class PythonWidgetModel implements IDisposable {
       },
       type: 'notebook'
     });
-    const executor = new KernelExecutor({
+    const framework = spkContent.framework;
+    const ServerClass = PYTHON_SERVER.get(framework);
+    if (!ServerClass) {
+      return {
+        success: false,
+        error: `Framework "${framework}" is not supported. Please check your .spk file.`
+      };
+    }
+    const executor = (this._executor = new ServerClass({
       sessionConnection: this._sessionConnection
-    });
+    }));
     const data = await this._connectionManager.registerConnection(executor);
     await executor.init({
       initCode: entryContent.content,
+      entryPath: spkContent.entry,
       ...data
     });
     const finish = new PromiseDelegate<void>();
@@ -82,9 +109,13 @@ export class PythonWidgetModel implements IDisposable {
 
     await finish.promise;
     this._kernelStarted = true;
-    return data;
+    return { ...data, rootUrl, framework, success: true };
   }
   dispose(): void {
+    if (this._isDisposed) {
+      return;
+    }
+    void this._executor?.disposePythonServer();
     this._isDisposed = true;
   }
 
@@ -95,10 +126,13 @@ export class PythonWidgetModel implements IDisposable {
   private _context: DocumentRegistry.IContext<DocumentRegistry.IModel>;
   private _connectionManager: IConnectionManager;
   private _contentsManager: Contents.IManager;
+  private _jpackModel: IJupyterPackFileFormat;
+  private _executor?: IKernelExecutor;
 }
 
 export namespace PythonWidgetModel {
   export interface IOptions {
+    jpackModel: IJupyterPackFileFormat;
     context: DocumentRegistry.IContext<DocumentRegistry.IModel>;
     manager: ServiceManager.IManager;
     connectionManager: IConnectionManager;

package/src/swConnection/index.ts

@@ -8,7 +8,7 @@ import { expose } from 'comlink';
 
 import { IConnectionManagerToken } from '../token';
 import { IConnectionManager, MessageAction } from '../type';
-import { ConnectionManager } from './connection_manager';
+import { ConnectionManager } from './mainConnectionManager';
 
 const fullLabextensionsUrl = PageConfig.getOption('fullLabextensionsUrl');
 const SCOPE = `${fullLabextensionsUrl}/jupyterpack/static`;
@@ -66,7 +66,6 @@ export const swPlugin: JupyterFrontEndPlugin<IConnectionManager> = {
   autoStart: true,
   provides: IConnectionManagerToken,
   activate: async (app: JupyterFrontEnd): Promise<IConnectionManager> => {
-    console.log('Activating jupyterpack service worker');
     const serviceWorker = await initServiceWorker();
     if (!serviceWorker) {
       throw new Error(
@@ -75,6 +74,10 @@ export const swPlugin: JupyterFrontEndPlugin<IConnectionManager> = {
     }
 
     const instanceId = UUID.uuid4();
+    console.log(
+      'Activating jupyterpack service worker with instance id',
+      instanceId
+    );
     const { port1: mainToServiceWorker, port2: serviceWorkerToMain } =
       new MessageChannel();
 

package/src/swConnection/mainConnectionManager.ts

@@ -0,0 +1,121 @@
+import { arrayBufferToBase64 } from '../tools';
+import {
+  IBroadcastMessage,
+  IConnectionManager,
+  IDict,
+  IKernelExecutor
+} from '../type';
+import { UUID } from '@lumino/coreutils';
+
+/**
+ * Manages connections between clients and kernel executors.
+ * This class handles the registration of kernel executors and the generation of responses
+ * for client requests. It maintains a mapping of kernel client IDs to their respective executors.
+ * The HTTP requests intercepted by the service worker are forwarded to the appropriate kernel executor.
+ * The websocket messages forwarded from the broadcast channel are also forwarded to the appropriate kernel executor.
+ * 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();
+  }
+
+  async registerConnection(
+    kernelExecutor: IKernelExecutor
+  ): Promise<{ instanceId: string; kernelClientId: string }> {
+    const uuid = UUID.uuid4();
+
+    this._kernelExecutors.set(uuid, kernelExecutor);
+
+    return { instanceId: this.instanceId, kernelClientId: uuid };
+  }
+
+  async generateResponse(options: {
+    kernelClientId: string;
+    urlPath: string;
+    method: string;
+    headers: IDict;
+    requestBody?: ArrayBuffer;
+    params?: string;
+  }): Promise<IDict | null> {
+    const { urlPath, kernelClientId, method, params, requestBody, headers } =
+      options;
+    const executor = this._kernelExecutors.get(kernelClientId);
+    if (!executor) {
+      return null;
+    }
+
+    const response = await executor.getResponse({
+      urlPath,
+      method,
+      params,
+      headers,
+      requestBody
+    });
+    return response;
+  }
+  private _initWsChannel() {
+    this._wsBroadcastChannel.onmessage = event => {
+      const rawData = event.data;
+      let data: IBroadcastMessage;
+      if (typeof rawData === 'string') {
+        data = JSON.parse(rawData);
+      } else {
+        data = rawData;
+      }
+
+      const { action, dest, wsUrl, payload } = data;
+      const executor = this._kernelExecutors.get(dest);
+      if (!executor) {
+        console.error(
+          'Missing kernel handle for message',
+          data,
+          dest,
+          this._kernelExecutors
+        );
+        return;
+      }
+
+      switch (action) {
+        case 'open': {
+          executor.openWebsocket({
+            instanceId: this.instanceId,
+            kernelId: dest,
+            wsUrl,
+            protocol: payload.protocol
+          });
+          break;
+        }
+        case 'send': {
+          let serializedData: string;
+          let isBinary: boolean;
+          if (payload instanceof ArrayBuffer || ArrayBuffer.isView(payload)) {
+            // Convert data to base64 string
+            serializedData = arrayBufferToBase64(payload as any);
+            isBinary = true;
+          } else if (typeof payload === 'string') {
+            serializedData = payload;
+            isBinary = false;
+          } else {
+            console.error('Unknown message type', payload);
+            return;
+          }
+          executor.sendWebsocketMessage({
+            instanceId: this.instanceId,
+            kernelId: dest,
+            wsUrl,
+            message: JSON.stringify({ isBinary, data: serializedData })
+          });
+          break;
+        }
+        default:
+          break;
+      }
+    };
+  }
+  private _kernelExecutors = new Map<string, IKernelExecutor>();
+  private _wsBroadcastChannel: BroadcastChannel;
+}

package/src/swConnection/sw.ts

@@ -1,6 +1,6 @@
 // import { expose } from 'comlink';
 import { MessageAction } from '../type';
-import { CommManager } from './comm_manager';
+import { CommManager } from './swCommManager';
 
 const COMM_MANAGER = new CommManager();
 /**

package/src/swConnection/{comm_manager.ts → swCommManager.ts}

@@ -1,5 +1,11 @@
 import { IConnectionManager, IDict } from '../type';
 import { wrap, transfer } from 'comlink';
+
+/**
+ * Manages communication between different components using Comlink's MessagePort-based communication.
+ * This class handles registration of communication channels and processing of requests.
+ * It's running on the service worker thread
+ */
 export class CommManager {
   constructor() {}
   registerComm(instanceId: string, port: MessagePort): void {

package/src/tools.ts

@@ -16,3 +16,72 @@ export function arrayBufferToBase64(buffer: ArrayBuffer) {
   }
   return btoa(binary);
 }
+
+export function base64ToArrayBuffer(base64: string): Uint8Array {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+
+export function base64ToString(base64: string): string {
+  const bytes = base64ToArrayBuffer(base64);
+  return new TextDecoder('utf-8').decode(bytes);
+}
+
+export function stringOrNone(content?: string) {
+  return content ? `"${content}"` : 'None';
+}
+
+export function isBinaryContentType(contentType?: string) {
+  if (!contentType) {
+    // no Content-Type → assume binary for safety
+    return true;
+  }
+
+  contentType = contentType.toLowerCase().trim();
+
+  const textTypes = [
+    'text/',
+    'application/json',
+    'application/javascript',
+    'application/xml',
+    'application/xhtml+xml',
+    'application/x-www-form-urlencoded',
+    'application/sql',
+    'application/graphql',
+    'application/yaml'
+  ];
+
+  const binaryIndicators = [
+    'image/',
+    'audio/',
+    'video/',
+    'font/',
+    'application/octet-stream',
+    'application/pdf',
+    'application/zip',
+    'application/x-protobuf',
+    'application/vnd'
+  ];
+
+  // Starts with text/ or one of the textual types
+  if (textTypes.some(t => contentType.startsWith(t))) {
+    return false;
+  }
+
+  // Starts with binary-indicating prefix
+  if (binaryIndicators.some(t => contentType.startsWith(t))) {
+    return true;
+  }
+
+  // If charset is specified → text
+  if (contentType.includes('charset=')) {
+    return false;
+  }
+
+  // Default: assume binary
+  return true;
+}

package/src/type.ts

@@ -5,15 +5,32 @@ export interface IDict<T = any> {
   [key: string]: T;
 }
 
+export interface IBroadcastMessage {
+  action:
+    | 'message'
+    | 'open'
+    | 'close'
+    | 'error'
+    | 'send'
+    | 'connected'
+    | 'backend_message';
+  dest: string;
+  wsUrl: string;
+  payload?: any;
+}
+
 export enum JupyterPackFramework {
   REACT = 'react',
-  DASH = 'dash'
+  DASH = 'dash',
+  STREAMLIT = 'streamlit',
+  TORNADO = 'tornado'
 }
 export interface IJupyterPackFileFormat {
   entry: string;
   framework: JupyterPackFramework;
   name?: string;
   metadata?: IDict;
+  rootUrl?: string;
 }
 
 export enum MessageAction {
@@ -29,9 +46,36 @@ export interface IKernelExecutorParams {
 }
 export interface IKernelExecutor extends IDisposable {
   getResponse(options: IKernelExecutorParams): Promise<IDict>;
+  openWebsocket(options: {
+    instanceId: string;
+    kernelId: string;
+    wsUrl: string;
+    protocol?: string;
+  }): Promise<void>;
+  sendWebsocketMessage(options: {
+    instanceId: string;
+    kernelId: string;
+    wsUrl: string;
+    message: string;
+  }): Promise<void>;
   executeCode(
-    code: KernelMessage.IExecuteRequestMsg['content']
-  ): Promise<string>;
+    code: KernelMessage.IExecuteRequestMsg['content'],
+    waitForResult?: boolean
+  ): Promise<string | null>;
+  init(options: {
+    entryPath?: string;
+    initCode?: string;
+    instanceId: string;
+    kernelClientId: string;
+  }): Promise<void>;
+  disposePythonServer(): Promise<void>;
+  getResponseFunctionFactory(options: {
+    urlPath: string;
+    method: string;
+    headers: IDict;
+    params?: string;
+    content?: string;
+  }): string;
 }
 
 export interface IConnectionManager {

package/src/websocket/websocket.ts

@@ -0,0 +1,216 @@
+(() => {
+  const urlPath = new URL(window.location.href).pathname;
+  const pathAfterExtensionName: string | undefined = urlPath.split(
+    '/jupyterpack/static'
+  )[1];
+  const pathList = pathAfterExtensionName?.split('/').filter(Boolean);
+  const instanceId = pathList?.[0];
+  const kernelClientId = pathList?.[2];
+  if (!instanceId || !kernelClientId) {
+    throw new Error('Missing instance Id or kernelClient Id');
+  }
+
+  interface IBroadcastMessage {
+    action:
+      | 'message'
+      | 'open'
+      | 'close'
+      | 'error'
+      | 'send'
+      | 'connected'
+      | 'backend_message';
+    dest: string;
+    wsUrl: string;
+    payload?: any;
+  }
+
+  const sendTypedMessage = (msg: Omit<IBroadcastMessage, 'dest'>) => {
+    bcWsChannel.postMessage({ ...msg, dest: kernelClientId });
+  };
+
+  function base64ToBinary(base64: string, dataType: BinaryType) {
+    const binary = atob(base64); // decode base64
+    const len = binary.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    if (dataType === 'arraybuffer') {
+      return bytes.buffer;
+    } else if (dataType === 'blob') {
+      return new Blob([bytes], { type: 'application/octet-stream' });
+    } else {
+      throw new Error("Unsupported type: use 'arraybuffer' or 'blob'");
+    }
+  }
+
+  const decodeServerMessage = (
+    payload: {
+      data: string;
+      isBinary: boolean;
+    },
+    binaryType: BinaryType
+  ) => {
+    const { data, isBinary } = payload;
+    if (isBinary) {
+      // Decode base64 string to array buffer or blob
+
+      return base64ToBinary(data, binaryType);
+    }
+    return data;
+  };
+  const bcWsChannel = new BroadcastChannel(`/jupyterpack/ws/${instanceId}`);
+
+  class BroadcastChannelWebSocket implements WebSocket {
+    constructor(url: string | URL, protocols?: string | string[]) {
+      const urlObj = new URL(url);
+      this.url = urlObj.pathname + urlObj.search + urlObj.hash;
+
+      if (protocols) {
+        this.protocol = Array.isArray(protocols)
+          ? protocols.join(',')
+          : protocols;
+      } else {
+        this.protocol = '';
+      }
+      this.binaryType = 'blob';
+      this.bufferedAmount = 0;
+      this.extensions = '';
+
+      this.readyState = this.CONNECTING;
+      this._open();
+    }
+
+    onclose: ((this: WebSocket, ev?: CloseEvent) => any) | null = () => {
+      // no-op
+    };
+    onerror: ((this: WebSocket, ev: Event) => any) | null = () => {
+      // no-op
+    };
+    onmessage:
+      | ((this: WebSocket, ev: MessageEvent | { data: any }) => any)
+      | null = () => {
+      // no-op
+    };
+    onopen: ((this: WebSocket, ev: Event | { data: any }) => any) | null =
+      () => {
+        // no-op
+      };
+    close(code?: unknown, reason?: unknown): void {
+      if (this.readyState === this.CLOSED) {
+        return;
+      }
+
+      if (this.onclose) {
+        this.onclose();
+      }
+      while (this._eventHandlers['close'].length) {
+        const cb = this._eventHandlers['close'].pop();
+        cb();
+      }
+      this._eventHandlers['close'] = [];
+      bcWsChannel.removeEventListener('message', this._bcMessageHandler);
+
+      this.readyState = this.CLOSED;
+    }
+    send(data: unknown): void {
+      sendTypedMessage({
+        action: 'send',
+        payload: data,
+        wsUrl: this.url
+      });
+    }
+
+    addEventListener(
+      type: 'message' | 'open' | 'close' | 'error',
+      listener: unknown,
+      options?: unknown
+    ): void {
+      this._eventHandlers[type].push(listener);
+    }
+    removeEventListener(
+      type: 'message' | 'open' | 'close' | 'error',
+      listener: unknown,
+      options?: unknown
+    ): void {
+      this._eventHandlers[type] = this._eventHandlers[type].filter(
+        handler => handler !== listener
+      );
+    }
+
+    dispatchEvent(event: unknown): boolean {
+      return true;
+    }
+    readyState: number;
+    url: string;
+    protocol: string;
+    binaryType: BinaryType;
+    bufferedAmount: number;
+    extensions: string;
+
+    readonly CONNECTING = 0;
+    readonly OPEN = 1;
+    readonly CLOSING = 2;
+    readonly CLOSED = 3;
+
+    private _eventHandlers: {
+      message: any[];
+      open: any[];
+      close: any[];
+      error: any[];
+    } = { message: [], open: [], close: [], error: [] };
+
+    private _bcMessageHandler = async (event: MessageEvent) => {
+      const rawData = event.data;
+      let data: IBroadcastMessage;
+      if (typeof rawData === 'string') {
+        data = JSON.parse(rawData);
+      } else {
+        data = rawData;
+      }
+      const { action, dest, wsUrl, payload } = data;
+      if (dest !== kernelClientId || wsUrl !== this.url) {
+        return;
+      }
+      switch (action) {
+        case 'connected': {
+          this.readyState = this.OPEN;
+
+          if (this.onopen) {
+            this.onopen(event);
+          }
+          this._eventHandlers.open.forEach(handler =>
+            handler({ data: payload })
+          );
+          break;
+        }
+
+        case 'backend_message': {
+          const decoded = decodeServerMessage(payload, this.binaryType);
+          if (this.onmessage) {
+            this.onmessage({ data: decoded });
+          }
+          this._eventHandlers.message.forEach(handler =>
+            handler({ data: decoded })
+          );
+          break;
+        }
+        default:
+          break;
+      }
+    };
+    private _open = () => {
+      sendTypedMessage({
+        action: 'open',
+        payload: {
+          protocol: this.protocol
+        },
+        wsUrl: this.url
+      });
+
+      bcWsChannel.addEventListener('message', this._bcMessageHandler);
+    };
+  }
+
+  window.WebSocket = BroadcastChannelWebSocket as any;
+})();

package/lib/pythonWidget/connectionManager.js

@@ -1,27 +0,0 @@
-import { UUID } from '@lumino/coreutils';
-export class ConnectionManager {
-    constructor(instanceId) {
-        this.instanceId = instanceId;
-        this._kernelExecutors = new Map();
-    }
-    async registerConnection(kernelExecutor) {
-        const uuid = UUID.uuid4();
-        this._kernelExecutors.set(uuid, kernelExecutor);
-        return { instanceId: this.instanceId, kernelClientId: uuid };
-    }
-    async generateResponse(options) {
-        const { urlPath, kernelClientId, method, params, requestBody, headers } = options;
-        const executor = this._kernelExecutors.get(kernelClientId);
-        if (!executor) {
-            return null;
-        }
-        const response = await executor.getResponse({
-            urlPath,
-            method,
-            params,
-            headers,
-            requestBody
-        });
-        return response;
-    }
-}