jupyterpack 0.2.1 → 0.4.0

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

@@ -1,6 +1,10 @@
 import { Token } from '@lumino/coreutils';
-import { IConnectionManager } from './type';
+import { IConnectionManager, IJupyterpackDocTracker } from './type';
 
 export const IConnectionManagerToken = new Token<IConnectionManager>(
   'jupyterpack:connection-manager'
 );
+
+export const IJupyterpackDocTrackerToken = new Token<IJupyterpackDocTracker>(
+  'jupyterpack:dock-tracker'
+);

package/src/tools.ts

@@ -1,3 +1,25 @@
+import logoStr from '../style/icons/box.svg';
+import autoReloadStr from '../style/icons/autoreload.svg';
+import linkStr from '../style/icons/externallink.svg';
+import { LabIcon } from '@jupyterlab/ui-components';
+
+export const IS_LITE = !!document.getElementById('jupyter-lite-main');
+
+export const logoIcon = new LabIcon({
+  name: 'jupyterpack:logo',
+  svgstr: logoStr
+});
+
+export const autoReloadIcon = new LabIcon({
+  name: 'jupyterpack:autoReload',
+  svgstr: autoReloadStr
+});
+
+export const linkIcon = new LabIcon({
+  name: 'jupyterpack:externalLink',
+  svgstr: linkStr
+});
+
 export function removePrefix(path: string, prefix: string): string {
   if (path.startsWith(prefix)) {
     return path.slice(prefix.length);
@@ -16,3 +38,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

@@ -1,19 +1,41 @@
+import { DocumentWidget } from '@jupyterlab/docregistry';
 import { KernelMessage } from '@jupyterlab/services';
 import { IDisposable } from '@lumino/disposable';
+import { IWidgetTracker } from '@jupyterlab/apputils';
+import { ISignal } from '@lumino/signaling';
 
 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;
+  metadata?: {
+    autoreload?: boolean;
+  };
+  rootUrl?: string;
 }
 
 export enum MessageAction {
@@ -29,9 +51,40 @@ 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>;
+  reloadPythonServer(options: {
+    entryPath?: string;
+    initCode?: string;
+  }): Promise<void>;
+  getResponseFunctionFactory(options: {
+    urlPath: string;
+    method: string;
+    headers: IDict;
+    params?: string;
+    content?: string;
+  }): string;
 }
 
 export interface IConnectionManager {
@@ -42,3 +95,22 @@ export interface IConnectionManager {
     option: { kernelClientId: string } & IKernelExecutorParams
   ): Promise<IDict | null>;
 }
+
+export type IJupyterpackDocTracker = IWidgetTracker<DocumentWidget>;
+
+export interface IPythonWidgetModel extends IDisposable {
+  connectionManager: IConnectionManager;
+  serverReloaded: ISignal<IPythonWidgetModel, void>;
+  kernelStatusChanged: ISignal<IPythonWidgetModel, 'started' | 'stopped'>;
+  reload(): Promise<void>;
+  initialize(): Promise<
+    | {
+        success: true;
+        instanceId: string;
+        kernelClientId: string;
+        rootUrl: string;
+        framework: JupyterPackFramework;
+      }
+    | { success: false; error: string }
+  >;
+}

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/style/base.css

@@ -49,3 +49,10 @@
       0 0 0 0 rgb(212 72 13 / 100%);
   }
 }
+
+.specta-main-content-panel .jupyterpack-toolbar {
+  display: none;
+  height: 0 !important;
+  width: 0 !important;
+  min-height: 0 !important;
+}

package/style/icons/autoreload.svg

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<svg height="800px" width="800px" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg">
+	<g>
+		<path d="M403.925,108.102c-27.595-27.595-62.899-47.558-102.459-56.29L304.182,0L201.946,53.867l-27.306,14.454
+		l-5.066,2.654l8.076,4.331l38.16,20.542l81.029,43.602l2.277-42.859c28.265,7.546,53.438,22.53,73.623,42.638
+		c29.94,29.939,48.358,71.119,48.358,116.776c0,23.407-4.843,45.58-13.575,65.687l40.37,17.532
+		c11.076-25.463,17.242-53.637,17.242-83.219C465.212,198.306,441.727,145.904,403.925,108.102z"
+			fill="var(--jp-inverse-layout-color3)" />
+		<path d="M296.256,416.151l-81.101-43.612l-2.272,42.869c-28.26-7.555-53.51-22.53-73.618-42.636
+		c-29.945-29.95-48.364-71.12-48.364-116.767c0-23.427,4.844-45.522,13.576-65.697l-40.37-17.531
+		c-11.076,25.53-17.242,53.723-17.242,83.228c0,57.679,23.407,110.157,61.21,147.893c27.595,27.594,62.899,47.548,102.453,56.202
+		l-2.716,51.9l102.169-53.878l27.455-14.454l4.988-2.643l-7.999-4.332L296.256,416.151z"
+			fill="var(--jp-inverse-layout-color3)" />
+	</g>
+</svg>

package/style/icons/box.svg

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M17.5777 4.43152L15.5777 3.38197C13.8221 2.46066 12.9443 2 12 2C11.0557 2 10.1779 2.46066 8.42229 3.38197L6.42229 4.43152C4.64855 5.36234 3.6059 5.9095 2.95969 6.64132L12 11.1615L21.0403 6.64132C20.3941 5.9095 19.3515 5.36234 17.5777 4.43152Z"
+    fill="var(--jp-inverse-layout-color3)" />
+  <path
+    d="M21.7484 7.96435L12.75 12.4635V21.904C13.4679 21.7252 14.2848 21.2965 15.5777 20.618L17.5777 19.5685C19.7294 18.4393 20.8052 17.8748 21.4026 16.8603C22 15.8458 22 14.5833 22 12.0585V11.9415C22 10.0489 22 8.86558 21.7484 7.96435Z"
+    fill="var(--jp-inverse-layout-color3)" />
+  <path
+    d="M11.25 21.904V12.4635L2.25164 7.96434C2 8.86557 2 10.0489 2 11.9415V12.0585C2 14.5833 2 15.8458 2.5974 16.8603C3.19479 17.8748 4.27063 18.4393 6.42229 19.5685L8.42229 20.618C9.71524 21.2965 10.5321 21.7252 11.25 21.904Z"
+    fill="var(--jp-inverse-layout-color3)" />
+</svg>

package/style/icons/externallink.svg

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <g>
+    <path id="Vector"
+      d="M10.0002 5H8.2002C7.08009 5 6.51962 5 6.0918 5.21799C5.71547 5.40973 5.40973 5.71547 5.21799 6.0918C5 6.51962 5 7.08009 5 8.2002V15.8002C5 16.9203 5 17.4801 5.21799 17.9079C5.40973 18.2842 5.71547 18.5905 6.0918 18.7822C6.5192 19 7.07899 19 8.19691 19H15.8031C16.921 19 17.48 19 17.9074 18.7822C18.2837 18.5905 18.5905 18.2839 18.7822 17.9076C19 17.4802 19 16.921 19 15.8031V14M20 9V4M20 4H15M20 4L13 11"
+      stroke="var(--jp-inverse-layout-color3)" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+  </g>
+</svg>

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;
-    }
-}

package/lib/pythonWidget/kernelExecutor.d.ts

@@ -1,27 +0,0 @@
-import { KernelMessage, Session } from '@jupyterlab/services';
-import { IDict, IKernelExecutor } from '../type';
-export declare class KernelExecutor implements IKernelExecutor {
-    constructor(options: KernelExecutor.IOptions);
-    get isDisposed(): boolean;
-    init(options: {
-        initCode?: string;
-        instanceId: string;
-        kernelClientId: string;
-    }): Promise<void>;
-    getResponse(options: {
-        method: string;
-        urlPath: string;
-        headers: IDict;
-        requestBody?: ArrayBuffer;
-        params?: string;
-    }): Promise<IDict>;
-    executeCode(code: KernelMessage.IExecuteRequestMsg['content']): Promise<string>;
-    dispose(): void;
-    private _isDisposed;
-    private _sessionConnection;
-}
-export declare namespace KernelExecutor {
-    interface IOptions {
-        sessionConnection: Session.ISessionConnection;
-    }
-}

package/lib/pythonWidget/kernelExecutor.js

@@ -1,104 +0,0 @@
-import { PageConfig, URLExt } from '@jupyterlab/coreutils';
-import { arrayBufferToBase64 } from '../tools';
-export class KernelExecutor {
-    constructor(options) {
-        this._isDisposed = false;
-        this._sessionConnection = options.sessionConnection;
-    }
-    get isDisposed() {
-        return this._isDisposed;
-    }
-    async init(options) {
-        const { initCode, instanceId, kernelClientId } = options;
-        const labBaseUrl = PageConfig.getOption('baseUrl');
-        const baseURL = URLExt.join(labBaseUrl, 'extensions/jupyterpack/static', instanceId, 'dash', kernelClientId, '/');
-        const osCode = `
-    import os
-    os.environ['DASH_URL_BASE_PATHNAME'] = '${baseURL}'
-    `;
-        await this.executeCode({ code: osCode });
-        if (initCode) {
-            await this.executeCode({ code: initCode });
-        }
-        const serverCode = `
-    import httpx, json, base64
-    __monstra_transport = httpx.WSGITransport(app=app.server)
-    def __monstra_get_response(method, url, headers, content=None, params=None):
-      decoded_content = None
-      if content is not None:
-        content = base64.b64decode(content)
-        decoded_content = content.decode()
-      with httpx.Client(transport=__monstra_transport, base_url="http://testserver") as client:
-        r = client.request(method, url, headers=headers, content=content, params=params)
-        response = {
-          "headers": dict(r.headers),
-          "content": r.text,
-          "status_code": r.status_code,
-          "original_request": {"method": method, "url": url, "content": decoded_content, "params": params, "headers": headers},
-        }
-        json_str = json.dumps(response)
-        b64_str = base64.b64encode(json_str.encode("utf-8")).decode("utf-8")
-        return b64_str
-    `;
-        await this.executeCode({ code: serverCode });
-    }
-    async getResponse(options) {
-        const { method, urlPath, requestBody, params, headers } = options;
-        const content = requestBody ? arrayBufferToBase64(requestBody) : undefined;
-        const code = `__monstra_get_response("${method}", "${urlPath}", headers=${JSON.stringify(headers)} , content=${content ? `"${content}"` : 'None'}, params=${params ? `"${params}"` : 'None'})`;
-        const raw = await this.executeCode({ code });
-        const jsonStr = atob(raw.slice(1, -1));
-        const obj = JSON.parse(jsonStr);
-        return obj;
-    }
-    async executeCode(code) {
-        var _a;
-        const kernel = (_a = this._sessionConnection) === null || _a === void 0 ? void 0 : _a.kernel;
-        if (!kernel) {
-            throw new Error('Session has no kernel.');
-        }
-        return new Promise((resolve, reject) => {
-            const future = kernel.requestExecute(code, false, undefined);
-            const parentMsgid = future.msg.header.msg_id;
-            let executeResult = '';
-            future.onIOPub = (msg) => {
-                const msgType = msg.header.msg_type;
-                switch (msgType) {
-                    case 'execute_result': {
-                        const content = msg.content
-                            .data['text/plain'];
-                        executeResult += content;
-                        break;
-                    }
-                    case 'status': {
-                        if (msg.content.execution_state ===
-                            'idle' &&
-                            msg.parent_header.msg_id === parentMsgid) {
-                            resolve(executeResult);
-                        }
-                        break;
-                    }
-                    case 'stream': {
-                        const content = msg.content.text;
-                        executeResult += content;
-                        break;
-                    }
-                    case 'error': {
-                        console.error('Kernel operation failed', msg.content);
-                        reject(msg.content);
-                        break;
-                    }
-                    default:
-                        break;
-                }
-            };
-        });
-    }
-    dispose() {
-        if (this._isDisposed) {
-            return;
-        }
-        this._isDisposed = true;
-        this._sessionConnection.dispose();
-    }
-}

package/lib/swConnection/comm_manager.d.ts

@@ -1,6 +0,0 @@
-export declare class CommManager {
-    constructor();
-    registerComm(instanceId: string, port: MessagePort): void;
-    generateResponse(request: Request): Promise<Response>;
-    private _commIds;
-}

package/lib/swConnection/connection_manager.d.ts

@@ -1,18 +0,0 @@
-import { IConnectionManager, IDict, IKernelExecutor } from '../type';
-export declare class ConnectionManager implements IConnectionManager {
-    instanceId: string;
-    constructor(instanceId: string);
-    registerConnection(kernelExecutor: IKernelExecutor): Promise<{
-        instanceId: string;
-        kernelClientId: string;
-    }>;
-    generateResponse(options: {
-        kernelClientId: string;
-        urlPath: string;
-        method: string;
-        headers: IDict;
-        requestBody?: ArrayBuffer;
-        params?: string;
-    }): Promise<IDict | null>;
-    private _kernelExecutors;
-}