jupyterpack 0.4.0 → 0.5.2

package/README.md

@@ -7,7 +7,8 @@
 
 ## Features
 
-- **Python Web Apps**: Serve Python web applications directly in the browser using JupyterLite's in-browser Python kernel. `jupyterpack` currently supports Dash.
+- **Python Web Apps**: Serve Python web applications directly in the browser using JupyterLite's in-browser Python kernel. `jupyterpack` currently supports Dash, Streamlit and Shiny for Python. You can also use `jupyterpack` to serve any `asgi` or `wsgi` Python web application.
+  .
 - **JavaScript Web Apps**: Bundle and serve JavaScript web applications using in-browser bundlers.
 
 ![Image](https://github.com/user-attachments/assets/22849fe8-199f-4d9f-ad45-055bccf88bad)
@@ -46,7 +47,90 @@ the `app.spk` is the entry point of your React app, it should contain the follow
 }
 ```
 
-Double clicking the `spk` file to open the web app as a tab of JupyterLab.
+Double-clicking the `spk` file to open the web app as a tab of JupyterLab.
+
+## `.spk` — Jupyter Pack File Format
+
+A **`.spk`** file describes how an application should be loaded, executed, and rendered in JupyterLite and JupyterLab.  
+It defines the **entry point**, **framework**, optional **dependencies**, and runtime **metadata**, allowing reproducible execution across environments.
+
+The file is expressed in **JSON**.
+
+### Basic Structure
+
+```typescript
+interface IJupyterPackFileFormat {
+  entry: string;
+  framework: JupyterPackFramework;
+  name?: string;
+  metadata?: {
+    autoreload?: boolean;
+  };
+  rootUrl?: string;
+  dependencies?: IDependencies;
+  disableDependencies?: boolean;
+}
+```
+
+- `entry` (required): Path to the main entry file of the application. For examples:
+  - _"app.py"_
+  - _"/index.html"_
+  - _"dashboard/index.py"_
+
+  The path is resolved relative to the .spk file location.
+
+- `framework` (required): The framework used to run the application. Supported frameworks are:
+
+  | Value       | Description                      |
+  | ----------- | -------------------------------- |
+  | `react`     | React-based frontend application |
+  | `dash`      | Plotly Dash application          |
+  | `streamlit` | Streamlit application            |
+  | `tornado`   | Tornado web application          |
+  | `shiny`     | Shiny application (Python)       |
+  | `starlette` | Starlette ASGI application       |
+
+- `name` (optional): The name of the application. If not provided, the name will be the name of the .spk file.
+
+- `metadata` (optional): Additional metadata for the application.
+  - `autoreload`: Enables automatic reload when source files change.
+
+- `rootUrl` (optional): The root URL of the web application. Default is `/`
+
+- `dependencies` (optional): The dependencies of the web application. It will be merged with the default dependencies of the selected framework
+  - `mamba`: Emscripten-forge packages
+  - `pip`: PYPI packages
+    Example:
+    ```typescript
+    dependencies: {
+      mamba: ['numpy, scipy'];
+      pip: ['plotly'];
+    }
+    ```
+
+  You only need to specify the dependencies of the application, the required dependencies of the framework will be automatically added.
+
+- `disableDependencies` (optional): Disable entirely the dependency installation. This is useful when dependencies are already provided by the environment. Default is `false`.
+
+### Full example
+
+```json
+{
+  "name": "Sales Dashboard",
+  "entry": "app.py",
+  "framework": "streamlit",
+  "rootUrl": "/",
+  "metadata": {
+    "autoreload": true
+  },
+  "dependencies": {
+    "mamba": ["numpy", "pandas"],
+    "pip": []
+  }
+}
+```
+
+## Framework-specific configurations
 
 ### Dash application
 
@@ -68,7 +152,27 @@ the `app.spk` is the entry point of your Dash app, it should contain the followi
 }
 ```
 
-For the Dash code, you need to define your Dash app variable as `app` and do not call `app.run_server` directly, `jupyterpack` will handle the server for you. Just as the case of React app, double clicking the spk file will open the Dash app in a new JupyterLab tab.
+For Dash applications, you must define your Dash instance as a variable named `app`.  
+Do **not** call `app.run_server()` yourself — `jupyterpack` is responsible for starting and managing the server lifecycle.
+
+As with React applications, double-clicking the `.spk` file will open the Dash app in a new JupyterLab tab.
+
+### Streamlit application
+
+Streamlit applications follow a similar structure to Dash apps.
+Write your code as a standard Streamlit application and do **not** start the server manually — `jupyterpack` will handle execution and serving automatically.
+
+Opening the `.spk` file will launch the Streamlit app in a new JupyterLab tab.
+
+### Shiny application
+
+Shiny applications also follow a structure similar to Dash apps.  
+`jupyterpack` supports both **Shiny Express** and **Shiny Core** applications.
+
+- **Shiny Express**: no special requirements.
+- **Shiny Core**: the application instance must be assigned to a variable named `app`.
+
+In both cases, the server is managed by `jupyterpack`, and opening the `.spk` file will launch the app in JupyterLab.
 
 ## Try it online!
 

package/lib/document/widgetFactory.js

@@ -35,7 +35,9 @@ export class JupyterPackWidgetFactory extends ABCWidgetFactory {
                 }
                 case JupyterPackFramework.DASH:
                 case JupyterPackFramework.STREAMLIT:
-                case JupyterPackFramework.TORNADO: {
+                case JupyterPackFramework.TORNADO:
+                case JupyterPackFramework.STARLETTE:
+                case JupyterPackFramework.SHINY: {
                     const model = new PythonWidgetModel({
                         jpackModel,
                         context,

package/lib/pythonServer/baseServer.d.ts

@@ -0,0 +1,78 @@
+import { IBasePythonServer, IDependencies, IDict, IKernelExecutor, IPythonServerInitOptions, JupyterPackFramework } from '../type';
+import { KernelExecutor } from './kernelExecutor';
+export declare abstract class BasePythonServer implements IBasePythonServer {
+    constructor(options: KernelExecutor.IOptions);
+    abstract reloadPythonServer(options: {
+        entryPath?: string;
+        initCode?: string;
+    }): Promise<void>;
+    get isDisposed(): boolean;
+    get kernelExecutor(): IKernelExecutor;
+    dispose(): void;
+    init(options: IPythonServerInitOptions): Promise<void>;
+    disposePythonServer(): 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;
+    closeWebsocketFunctionFactory(options: {
+        instanceId: string;
+        kernelId: string;
+        wsUrl: string;
+    }): string;
+    sendWebsocketMessageFunctionFactory(options: {
+        instanceId: string;
+        kernelId: string;
+        wsUrl: string;
+        message: string;
+    }): string;
+    openWebsocket(options: {
+        instanceId: string;
+        kernelId: string;
+        wsUrl: string;
+        protocol?: string;
+    }): Promise<void>;
+    closeWebsocket(options: {
+        instanceId: string;
+        kernelId: string;
+        wsUrl: string;
+    }): Promise<void>;
+    sendWebsocketMessage(options: {
+        instanceId: string;
+        kernelId: string;
+        wsUrl: string;
+        message: string;
+    }): Promise<void>;
+    getResponse(options: {
+        method: string;
+        urlPath: string;
+        headers: IDict;
+        requestBody?: ArrayBuffer;
+        params?: string;
+    }): Promise<IDict>;
+    protected buildBaseURL(options: {
+        instanceId: string;
+        kernelClientId: string;
+        framework: JupyterPackFramework;
+    }): string;
+    protected mergeDependencies(spkDeps?: IDependencies, defaultDeps?: IDependencies): IDependencies | undefined;
+    protected _baseUrl: string | undefined;
+    protected readonly _openedWebsockets: {
+        instanceId: string;
+        kernelId: string;
+        wsUrl: string;
+    }[];
+    protected readonly _server_var = "__jupyterpack_python_server";
+    private _kernelExecutor;
+    private _isDisposed;
+    private _wsPatch;
+}

package/lib/pythonServer/baseServer.js

@@ -0,0 +1,175 @@
+import { PageConfig, URLExt } from '@jupyterlab/coreutils';
+import { arrayBufferToBase64, base64ToArrayBuffer, base64ToString, isBinaryContentType, stringOrNone } from '../tools';
+import websocketPatch from '../websocket/websocket.js?raw';
+import { KernelExecutor } from './kernelExecutor';
+export class BasePythonServer {
+    constructor(options) {
+        this._openedWebsockets = [];
+        this._server_var = '__jupyterpack_python_server';
+        this._isDisposed = false;
+        this._kernelExecutor = new KernelExecutor(options);
+        this._wsPatch = websocketPatch.replaceAll('"use strict";', '');
+    }
+    get isDisposed() {
+        return this._isDisposed;
+    }
+    get kernelExecutor() {
+        return this._kernelExecutor;
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        this.disposePythonServer()
+            .then(() => {
+            this._kernelExecutor.dispose();
+        })
+            .catch(console.error);
+    }
+    async init(options) {
+        const patchCode = `
+    from jupyterpack.common import patch_all
+    patch_all()
+    `;
+        await this._kernelExecutor.executeCode({ code: patchCode });
+        if (!options.disableDependencies) {
+            const { dependencies } = options;
+            if (dependencies === null || dependencies === void 0 ? void 0 : dependencies.mamba) {
+                const mambaDeps = `
+      %mamba install ${dependencies.mamba.join(' ')}
+      True
+      `;
+                await this.kernelExecutor.executeCode({
+                    code: mambaDeps
+                }, true);
+            }
+            if (dependencies === null || dependencies === void 0 ? void 0 : dependencies.pip) {
+                const pipDeps = `
+        %pip install ${dependencies.pip.join(' ')}
+        True
+        `;
+                await this.kernelExecutor.executeCode({
+                    code: pipDeps
+                }, true);
+            }
+        }
+    }
+    async disposePythonServer() {
+        await this.kernelExecutor.executeCode({
+            code: `${this._server_var}.dispose()`
+        });
+        for (const element of this._openedWebsockets) {
+            await this.closeWebsocket(element);
+        }
+    }
+    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;
+    }
+    closeWebsocketFunctionFactory(options) {
+        const { instanceId, kernelId, wsUrl } = options;
+        const code = `await ${this._server_var}.close_ws("${instanceId}", "${kernelId}", "${wsUrl}")`;
+        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 openWebsocket(options) {
+        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) {
+        const code = this.closeWebsocketFunctionFactory(options);
+        if (code) {
+            await this._kernelExecutor.executeCode({ code });
+        }
+        else {
+            throw new Error('Missing websocket close code');
+        }
+    }
+    async sendWebsocketMessage(options) {
+        const code = this.sendWebsocketMessageFunctionFactory(options);
+        if (code) {
+            await this._kernelExecutor.executeCode({ code });
+        }
+        else {
+            throw new Error('Missing websocket send code');
+        }
+    }
+    async getResponse(options) {
+        var _a;
+        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 = JSON.parse(jsonStr);
+        const responseHeaders = JSON.parse(atob(obj.headers));
+        const contentType = (_a = responseHeaders === null || responseHeaders === void 0 ? void 0 : responseHeaders['Content-Type']) !== null && _a !== void 0 ? _a : responseHeaders === null || responseHeaders === void 0 ? void 0 : responseHeaders['content-type'];
+        let responseContent;
+        if (isBinaryContentType(contentType)) {
+            responseContent = base64ToArrayBuffer(obj.content);
+        }
+        else {
+            responseContent = base64ToString(obj.content);
+        }
+        if (contentType && contentType.toLowerCase().includes('text/html')) {
+            responseContent = responseContent.replace('<head>', `<head>\n<script>\n${this._wsPatch}\n</script>\n`);
+        }
+        const decodedObj = {
+            status_code: obj.status_code,
+            headers: responseHeaders,
+            content: responseContent
+        };
+        return decodedObj;
+    }
+    buildBaseURL(options) {
+        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;
+    }
+    mergeDependencies(spkDeps, defaultDeps) {
+        var _a, _b, _c, _d;
+        if (!spkDeps) {
+            return defaultDeps;
+        }
+        if (!defaultDeps) {
+            return spkDeps;
+        }
+        const merged = {};
+        merged.mamba = [...((_a = spkDeps.mamba) !== null && _a !== void 0 ? _a : []), ...((_b = defaultDeps.mamba) !== null && _b !== void 0 ? _b : [])];
+        merged.pip = [...((_c = spkDeps.pip) !== null && _c !== void 0 ? _c : []), ...((_d = defaultDeps.pip) !== null && _d !== void 0 ? _d : [])];
+        return merged;
+    }
+}

package/lib/pythonServer/dash/dashServer.d.ts

@@ -1,22 +1,9 @@
-import { IDict } from '../../type';
-import { KernelExecutor } from '../kernelExecutor';
-export declare class DashServer extends KernelExecutor {
-    init(options: {
-        initCode?: string;
-        instanceId: string;
-        kernelClientId: string;
-    }): Promise<void>;
-    getResponseFunctionFactory(options: {
-        urlPath: string;
-        method: string;
-        headers: IDict;
-        params?: string;
-        content?: string;
-    }): string;
-    disposePythonServer(): Promise<void>;
+import { IPythonServerInitOptions } from '../../type';
+import { BasePythonServer } from '../baseServer';
+export declare class DashServer extends BasePythonServer {
+    init(options: IPythonServerInitOptions): Promise<void>;
     reloadPythonServer(options: {
         entryPath?: string;
         initCode?: string;
     }): Promise<void>;
-    private _DASH_SERVER_VAR;
 }

package/lib/pythonServer/dash/dashServer.js

@@ -1,47 +1,39 @@
-import { stringOrNone } from '../../tools';
 import { JupyterPackFramework } from '../../type';
-import { KernelExecutor } from '../kernelExecutor';
-export class DashServer extends KernelExecutor {
-    constructor() {
-        super(...arguments);
-        this._DASH_SERVER_VAR = '__jupyterpack_dash_server';
-    }
+import { BasePythonServer } from '../baseServer';
+import { DEPENDENCIES } from './deps';
+export class DashServer extends BasePythonServer {
     async init(options) {
-        await super.init(options);
+        const mergedOptions = {
+            ...options,
+            dependencies: this.mergeDependencies(options.dependencies, DEPENDENCIES)
+        };
+        await super.init(mergedOptions);
         const { initCode, instanceId, kernelClientId } = options;
         const baseURL = this.buildBaseURL({
             instanceId,
             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) {
-        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() {
-        await this.executeCode({ code: `${this._DASH_SERVER_VAR}.dispose()` });
+        await this.kernelExecutor.executeCode({ code: loaderCode });
     }
     async reloadPythonServer(options) {
         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)` }, true);
+        await this.kernelExecutor.executeCode({ code: `${this._server_var}.reload(app)` }, true);
     }
 }

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

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

package/lib/pythonServer/dash/deps.js

@@ -0,0 +1,4 @@
+export const DEPENDENCIES = {
+    mamba: ['dash', 'werkzeug>=2.2,<3.0'],
+    pip: []
+};

package/lib/pythonServer/index.d.ts

@@ -1,5 +1,5 @@
-import { IKernelExecutor, JupyterPackFramework } from '../type';
+import { IBasePythonServer, JupyterPackFramework } from '../type';
 import { KernelExecutor } from './kernelExecutor';
-type KernelExecutorConstructor = new (options: KernelExecutor.IOptions) => IKernelExecutor;
-export declare const PYTHON_SERVER: Map<JupyterPackFramework, KernelExecutorConstructor>;
+type BasePythonServerConstructor = new (options: KernelExecutor.IOptions) => IBasePythonServer;
+export declare const PYTHON_SERVER: Map<JupyterPackFramework, BasePythonServerConstructor>;
 export {};

package/lib/pythonServer/index.js

@@ -1,9 +1,13 @@
 import { JupyterPackFramework } from '../type';
 import { DashServer } from './dash/dashServer';
+import { ShinyServer } from './shiny/shinyServer';
+import { StarletteServer } from './starlette/starletteServer';
 import { StreamlitServer } from './streamlit/streamlitServer';
 import { TornadoServer } from './tornado/tornadoServer';
 export const PYTHON_SERVER = new Map([
     [JupyterPackFramework.DASH, DashServer],
     [JupyterPackFramework.STREAMLIT, StreamlitServer],
-    [JupyterPackFramework.TORNADO, TornadoServer]
+    [JupyterPackFramework.TORNADO, TornadoServer],
+    [JupyterPackFramework.SHINY, ShinyServer],
+    [JupyterPackFramework.STARLETTE, StarletteServer]
 ]);

package/lib/pythonServer/kernelExecutor.d.ts

@@ -1,68 +1,12 @@
 import { KernelMessage, Session } from '@jupyterlab/services';
-import { IDict, IKernelExecutor, JupyterPackFramework } from '../type';
-export declare abstract class KernelExecutor implements IKernelExecutor {
+import { IKernelExecutor } from '../type';
+export declare class KernelExecutor implements IKernelExecutor {
     constructor(options: KernelExecutor.IOptions);
     get isDisposed(): boolean;
-    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;
-    init(options: {
-        entryPath?: string;
-        initCode?: string;
-        instanceId: string;
-        kernelClientId: string;
-    }): Promise<void>;
-    openWebsocketFunctionFactory(options: {
-        instanceId: string;
-        kernelId: string;
-        wsUrl: string;
-        protocol?: string;
-    }): string | undefined;
-    sendWebsocketMessageFunctionFactory(options: {
-        instanceId: string;
-        kernelId: string;
-        wsUrl: string;
-        message: string;
-    }): string | undefined;
-    openWebsocket(options: {
-        instanceId: string;
-        kernelId: string;
-        wsUrl: string;
-        protocol?: string;
-    }): Promise<void>;
-    sendWebsocketMessage(options: {
-        instanceId: string;
-        kernelId: string;
-        wsUrl: string;
-        message: string;
-    }): Promise<void>;
-    getResponse(options: {
-        method: string;
-        urlPath: string;
-        headers: IDict;
-        requestBody?: ArrayBuffer;
-        params?: string;
-    }): Promise<IDict>;
     executeCode(code: KernelMessage.IExecuteRequestMsg['content'], waitForResult?: boolean): Promise<string | null>;
     dispose(): void;
-    protected buildBaseURL(options: {
-        instanceId: string;
-        kernelClientId: string;
-        framework: JupyterPackFramework;
-    }): string;
-    protected _baseUrl: string | undefined;
     private _isDisposed;
     private _sessionConnection;
-    private _wsPatch;
 }
 export declare namespace KernelExecutor {
     interface IOptions {

package/lib/pythonServer/kernelExecutor.js

@@ -1,77 +1,12 @@
-import { PageConfig, URLExt } from '@jupyterlab/coreutils';
 import stripAnsi from 'strip-ansi';
-import { arrayBufferToBase64, base64ToArrayBuffer, base64ToString, isBinaryContentType } from '../tools';
-import websocketPatch from '../websocket/websocket.js?raw';
 export class KernelExecutor {
     constructor(options) {
         this._isDisposed = false;
         this._sessionConnection = options.sessionConnection;
-        this._wsPatch = websocketPatch.replaceAll('"use strict";', '');
     }
     get isDisposed() {
         return this._isDisposed;
     }
-    async init(options) {
-        const patchCode = `
-    from jupyterpack.common import patch_all
-    patch_all()
-    `;
-        await this.executeCode({ code: patchCode });
-    }
-    openWebsocketFunctionFactory(options) {
-        return undefined;
-    }
-    sendWebsocketMessageFunctionFactory(options) {
-        return undefined;
-    }
-    async openWebsocket(options) {
-        const code = this.openWebsocketFunctionFactory(options);
-        if (code) {
-            await this.executeCode({ code });
-        }
-    }
-    async sendWebsocketMessage(options) {
-        const code = this.sendWebsocketMessageFunctionFactory(options);
-        if (code) {
-            await this.executeCode({ code });
-        }
-    }
-    async getResponse(options) {
-        var _a;
-        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 = JSON.parse(jsonStr);
-        const responseHeaders = JSON.parse(atob(obj.headers));
-        const contentType = (_a = responseHeaders === null || responseHeaders === void 0 ? void 0 : responseHeaders['Content-Type']) !== null && _a !== void 0 ? _a : responseHeaders === null || responseHeaders === void 0 ? void 0 : responseHeaders['content-type'];
-        let responseContent;
-        if (isBinaryContentType(contentType)) {
-            responseContent = base64ToArrayBuffer(obj.content);
-        }
-        else {
-            responseContent = base64ToString(obj.content);
-        }
-        if (contentType && contentType.toLowerCase() === 'text/html') {
-            responseContent = responseContent.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, waitForResult) {
         var _a;
         const kernel = (_a = this._sessionConnection) === null || _a === void 0 ? void 0 : _a.kernel;
@@ -130,11 +65,4 @@ export class KernelExecutor {
         this._isDisposed = true;
         this._sessionConnection.dispose();
     }
-    buildBaseURL(options) {
-        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;
-    }
 }