jupyterpack 0.2.0 → 0.3.0

package/README.md

@@ -10,6 +10,8 @@
 - **Python Web Apps**: Serve Python web applications directly in the browser using JupyterLite's in-browser Python kernel. `jupyterpack` currently supports Dash.
 - **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)
+
 ## Installation
 
 You can install `jupyterpack` using `pip` or `conda`

package/lib/document/widgetFactory.js

@@ -32,8 +32,11 @@ export class JupyterPackWidgetFactory extends ABCWidgetFactory {
                     content.addWidget(jpContent);
                     break;
                 }
-                case JupyterPackFramework.DASH: {
+                case JupyterPackFramework.DASH:
+                case JupyterPackFramework.STREAMLIT:
+                case JupyterPackFramework.TORNADO: {
                     const model = new PythonWidgetModel({
+                        jpackModel,
                         context,
                         manager: this.options.manager,
                         contentsManager: this._contentsManager,

package/lib/pythonServer/common/generatedPythonFiles.d.ts

@@ -0,0 +1,2 @@
+export declare const patch = "\nimport pyodide_http\nimport collections\n\nif not hasattr(collections, \"MutableSet\"):\n    import collections.abc\n\n    collections.MutableSet = collections.abc.MutableSet\n\npyodide_http.patch_all()";
+export declare const tools = "\nimport importlib.util\nimport sys\nfrom types import ModuleType\n\nimport tempfile\nfrom pathlib import Path\nfrom typing import List\nimport os\n\nos.environ.setdefault(\"JUPYTERPACK_BASE_URL\", \"{{base_url}}\")\n\n\ndef __jupyterpack_import_from_path(module_name: str, path: str) -> ModuleType:\n    \"\"\"\n    Import a Python module from a given file path.\n    Always reloads (does not use sys.modules cache).\n    \"\"\"\n    # Remove from sys.modules if already loaded\n    if module_name in sys.modules:\n        del sys.modules[module_name]\n\n    spec = importlib.util.spec_from_file_location(module_name, path)\n    if spec is None or spec.loader is None:\n        raise ImportError(f\"Cannot import module {module_name} from {path}\")\n\n    module = importlib.util.module_from_spec(spec)\n    sys.modules[module_name] = module\n    spec.loader.exec_module(module)\n    return module\n\n\ndef __jupyterpack_create_mock_module(\n    module_names: List[str], mock_content: str, patch_parent=True\n):\n    tmpdir = tempfile.TemporaryDirectory()\n    package_dir = Path(tmpdir.name) / \"__jupyterpack_mock_module\"\n    package_dir.mkdir()\n    (package_dir / \"__init__.py\").write_text(mock_content)\n\n    sys.path.insert(0, tmpdir.name)\n    mock_module = importlib.import_module(\"__jupyterpack_mock_module\")\n    sys.path.pop(0)\n    for module_name in module_names:\n        if patch_parent:\n            parts = module_name.split(\".\")\n            for i in range(1, len(parts) + 1):\n                subpath = \".\".join(parts[:i])\n                sys.modules[subpath] = mock_module\n\n            for i in range(1, len(parts)):\n                parent_name = \".\".join(parts[:i])\n                child_name = \".\".join(parts[: i + 1])\n                parent_mod = sys.modules[parent_name]\n                child_mod = sys.modules[child_name]\n                setattr(parent_mod, parts[i], child_mod)\n        else:\n            sys.modules[module_name] = mock_module\n\n    return tmpdir\n";

package/lib/pythonServer/common/generatedPythonFiles.js

@@ -0,0 +1,72 @@
+// Auto-generated TypeScript file from Python files
+export const patch = `
+import pyodide_http
+import collections
+
+if not hasattr(collections, "MutableSet"):
+    import collections.abc
+
+    collections.MutableSet = collections.abc.MutableSet
+
+pyodide_http.patch_all()`;
+export const tools = `
+import importlib.util
+import sys
+from types import ModuleType
+
+import tempfile
+from pathlib import Path
+from typing import List
+import os
+
+os.environ.setdefault("JUPYTERPACK_BASE_URL", "{{base_url}}")
+
+
+def __jupyterpack_import_from_path(module_name: str, path: str) -> ModuleType:
+    """
+    Import a Python module from a given file path.
+    Always reloads (does not use sys.modules cache).
+    """
+    # Remove from sys.modules if already loaded
+    if module_name in sys.modules:
+        del sys.modules[module_name]
+
+    spec = importlib.util.spec_from_file_location(module_name, path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Cannot import module {module_name} from {path}")
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def __jupyterpack_create_mock_module(
+    module_names: List[str], mock_content: str, patch_parent=True
+):
+    tmpdir = tempfile.TemporaryDirectory()
+    package_dir = Path(tmpdir.name) / "__jupyterpack_mock_module"
+    package_dir.mkdir()
+    (package_dir / "__init__.py").write_text(mock_content)
+
+    sys.path.insert(0, tmpdir.name)
+    mock_module = importlib.import_module("__jupyterpack_mock_module")
+    sys.path.pop(0)
+    for module_name in module_names:
+        if patch_parent:
+            parts = module_name.split(".")
+            for i in range(1, len(parts) + 1):
+                subpath = ".".join(parts[:i])
+                sys.modules[subpath] = mock_module
+
+            for i in range(1, len(parts)):
+                parent_name = ".".join(parts[:i])
+                child_name = ".".join(parts[: i + 1])
+                parent_mod = sys.modules[parent_name]
+                child_mod = sys.modules[child_name]
+                setattr(parent_mod, parts[i], child_mod)
+        else:
+            sys.modules[module_name] = mock_module
+
+    return tmpdir
+`;

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

@@ -0,0 +1,24 @@
+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>;
+    openWebsocket(options: {
+        instanceId: string;
+        kernelId: string;
+        wsUrl: string;
+        protocol?: string;
+    }): Promise<void>;
+    private DASH_GET_RESPONSE_FUNCTION;
+}

package/lib/pythonServer/dash/dashServer.js

@@ -0,0 +1,39 @@
+import { stringOrNone } from '../../tools';
+import { JupyterPackFramework } from '../../type';
+import { patch } from '../common/generatedPythonFiles';
+import { KernelExecutor } from '../kernelExecutor';
+import { bootstrap, dashLoader } from './generatedPythonFiles';
+export class DashServer extends KernelExecutor {
+    constructor() {
+        super(...arguments);
+        this.DASH_GET_RESPONSE_FUNCTION = '__jupyterpack_dash_get_response';
+    }
+    async init(options) {
+        await super.init(options);
+        const { initCode, instanceId, kernelClientId } = options;
+        const baseURL = this.buildBaseURL({
+            instanceId,
+            kernelClientId,
+            framework: JupyterPackFramework.DASH
+        });
+        await this.executeCode({ code: patch });
+        await this.executeCode({
+            code: bootstrap.replaceAll('{{base_url}}', baseURL)
+        });
+        if (initCode) {
+            await this.executeCode({ code: initCode });
+        }
+        await this.executeCode({ code: dashLoader });
+    }
+    getResponseFunctionFactory(options) {
+        const { method, urlPath, headers, params, content } = options;
+        const code = `${this.DASH_GET_RESPONSE_FUNCTION}("${method}", "${urlPath}", headers=${JSON.stringify(headers)} , content=${stringOrNone(content)}, params=${stringOrNone(params)})`;
+        return code;
+    }
+    async disposePythonServer() {
+        //no-op
+    }
+    async openWebsocket(options) {
+        //no-op
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare const bootstrap = "\nimport os\n\nos.environ[\"DASH_URL_BASE_PATHNAME\"] = \"{{base_url}}\"\n";
+export declare const dashLoader = "\nimport httpx, json, base64\n__jupyterpack_dash_transport = httpx.WSGITransport(app=app.server)  # noqa\n\n\ndef __jupyterpack_dash_get_response(method, url, headers, content=None, params=None):\n    decoded_content = None\n    if content is not None:\n        decoded_content = base64.b64decode(content)\n        # decoded_content = content.decode()\n    with httpx.Client(\n        transport=__jupyterpack_dash_transport, base_url=\"http://testserver\"\n    ) as client:\n        r = client.request(\n            method, url, headers=headers, content=decoded_content, params=params\n        )\n        reply_headers = json.dumps(dict(r.headers)).encode(\"utf-8\")\n        response = {\n            \"headers\": base64.b64encode(reply_headers).decode(\"ascii\"),\n            \"content\": base64.b64encode(r.content).decode(\"ascii\"),\n            \"status_code\": r.status_code,\n        }\n        json_str = json.dumps(response)\n        return json_str\n";

package/lib/pythonServer/dash/generatedPythonFiles.js

@@ -0,0 +1,31 @@
+// Auto-generated TypeScript file from Python files
+export const bootstrap = `
+import os
+
+os.environ["DASH_URL_BASE_PATHNAME"] = "{{base_url}}"
+`;
+export const dashLoader = `
+import httpx, json, base64
+__jupyterpack_dash_transport = httpx.WSGITransport(app=app.server)  # noqa
+
+
+def __jupyterpack_dash_get_response(method, url, headers, content=None, params=None):
+    decoded_content = None
+    if content is not None:
+        decoded_content = base64.b64decode(content)
+        # decoded_content = content.decode()
+    with httpx.Client(
+        transport=__jupyterpack_dash_transport, base_url="http://testserver"
+    ) as client:
+        r = client.request(
+            method, url, headers=headers, content=decoded_content, params=params
+        )
+        reply_headers = json.dumps(dict(r.headers)).encode("utf-8")
+        response = {
+            "headers": base64.b64encode(reply_headers).decode("ascii"),
+            "content": base64.b64encode(r.content).decode("ascii"),
+            "status_code": r.status_code,
+        }
+        json_str = json.dumps(response)
+        return json_str
+`;

package/lib/pythonServer/index.d.ts

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

package/lib/pythonServer/index.js

@@ -0,0 +1,9 @@
+import { JupyterPackFramework } from '../type';
+import { DashServer } from './dash/dashServer';
+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]
+]);

package/lib/pythonServer/kernelExecutor.d.ts

@@ -0,0 +1,66 @@
+import { KernelMessage, Session } from '@jupyterlab/services';
+import { IDict, IKernelExecutor, JupyterPackFramework } from '../type';
+export declare abstract class KernelExecutor implements IKernelExecutor {
+    constructor(options: KernelExecutor.IOptions);
+    get isDisposed(): boolean;
+    abstract disposePythonServer(): 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;
+    private _isDisposed;
+    private _sessionConnection;
+    private _wsPatch;
+}
+export declare namespace KernelExecutor {
+    interface IOptions {
+        sessionConnection: Session.ISessionConnection;
+    }
+}

package/lib/pythonServer/kernelExecutor.js

@@ -0,0 +1,133 @@
+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';
+import { patch } from './common/generatedPythonFiles';
+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) {
+        await this.executeCode({ code: patch });
+    }
+    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;
+        if (!kernel) {
+            throw new Error('Session has no kernel.');
+        }
+        return new Promise((resolve, reject) => {
+            const future = kernel.requestExecute(code, false, undefined);
+            let executeResult = '';
+            future.onIOPub = (msg) => {
+                const msgType = msg.header.msg_type;
+                switch (msgType) {
+                    case 'execute_result': {
+                        if (waitForResult) {
+                            const content = msg.content
+                                .data['text/plain'];
+                            executeResult += content;
+                            resolve(executeResult);
+                        }
+                        break;
+                    }
+                    case 'stream': {
+                        const content = msg.content;
+                        if (content.name === 'stderr') {
+                            console.error('Kernel stream', content.text);
+                        }
+                        else {
+                            console.log('Kernel stream', content.text);
+                        }
+                        break;
+                    }
+                    case 'error': {
+                        console.error('Kernel operation failed', code.code, msg.content.traceback
+                            .map((it) => stripAnsi(it))
+                            .join('\n'));
+                        reject(msg.content);
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            };
+            if (!waitForResult) {
+                resolve(null);
+                // future.dispose() # TODO
+            }
+        });
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        this._sessionConnection.dispose();
+    }
+    buildBaseURL(options) {
+        const { instanceId, kernelClientId, framework } = options;
+        const labBaseUrl = PageConfig.getOption('baseUrl');
+        const baseURL = URLExt.join(labBaseUrl, 'extensions/jupyterpack/static', instanceId, framework, kernelClientId, '/');
+        return baseURL;
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare const bootstrap = "\nimport os\n\nimport threading\nimport streamlit.watcher.path_watcher\nimport contextlib\nimport streamlit.elements.spinner\n\nos.environ[\"PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION\"] = \"python\"\n\n\nclass MockedThread(threading.Thread):\n    def start(self):\n        threading.current_thread = lambda: self\n        try:\n            self.run()\n        except Exception as e:\n            raise e\n\n\nthreading.Thread = MockedThread\n\n\nclass WatcherMock:\n    def __init__(\n        self,\n        path,\n        callback,\n        glob_pattern: str | None = None,\n        allow_nonexistent: bool = False,\n    ) -> None:\n        pass\n\n    def close(self) -> None:\n        pass\n\n\nstreamlit.watcher.path_watcher.watchdog_available = False\nstreamlit.watcher.path_watcher.EventBasedPathWatcher = WatcherMock\nstreamlit.watcher.path_watcher._is_watchdog_available = lambda: False\nstreamlit.watcher.path_watcher.get_path_watcher_class = lambda x: WatcherMock\n\n\nclass MockThreading:\n    class Timer:\n        def __init__(self, delay, cb):\n            cb()\n\n        def start(self):\n            pass\n\n    Lock = contextlib.nullcontext\n\n\nstreamlit.elements.spinner.threading = MockThreading\n";
+export declare const streamlitLoader = "\nimport json\nfrom streamlit import config\nimport streamlit.web.server.server as st_server\nfrom streamlit.runtime.runtime import Runtime\n\ntry:\n    # Check if __jupyterpack_streamlit_instance defined from previous run\n    __jupyterpack_streamlit_instance\nexcept NameError:\n    __jupyterpack_streamlit_instance = {\n        \"tornado_bridge\": None,\n        \"streamlit_server\": None,\n    }\n\n\ndef __jupyterpack_create_streamlit_app(base_url, script_path):\n    if Runtime._instance is not None:\n        Runtime._instance.stop()\n        Runtime._instance = None\n    config.set_option(\"server.baseUrlPath\", base_url)\n\n    config.set_option(\"server.port\", 6789)\n    config.set_option(\"server.enableCORS\", False)\n    config.set_option(\"server.enableXsrfProtection\", False)\n\n    streamlit_server = st_server.Server(script_path, True)\n    return streamlit_server\n\n\ndef __jupyterpack_streamlit_dispose():\n    global __jupyterpack_streamlit_instance\n    streamlit_server = __jupyterpack_streamlit_instance.get(\"streamlit_server\", None)\n    if streamlit_server:\n        streamlit_server._runtime.stop()\n\n    __jupyterpack_streamlit_instance = {\n        \"tornado_bridge\": None,\n        \"streamlit_server\": None,\n    }\n    del streamlit_server\n\n\nasync def __jupyterpack_streamlit_open_ws(\n    instance_id: str, kernel_client_id: str, ws_url: str, protocols_str: str | None\n):\n    tornado_bridge = __jupyterpack_streamlit_instance[\"tornado_bridge\"]\n    if tornado_bridge is None:\n        raise Exception(\"Missing tornado instance\")\n    await tornado_bridge.open_ws(instance_id, kernel_client_id, ws_url, protocols_str)\n\n\nasync def __jupyterpack_streamlit_receive_ws_message(\n    instance_id: str, kernel_client_id: str, ws_url: str, payload_message: str\n):\n    tornado_bridge = __jupyterpack_streamlit_instance[\"tornado_bridge\"]\n    if tornado_bridge is None:\n        raise Exception(\"Missing tornado instance\")\n    await tornado_bridge.receive_ws_message_from_js(\n        instance_id, kernel_client_id, ws_url, payload_message\n    )\n\n\nasync def __jupyterpack_streamlit_get_response(\n    method, url, headers, content=None, params=None\n):\n    global __jupyterpack_streamlit_instance\n    if not __jupyterpack_streamlit_instance[\"streamlit_server\"]:\n        streamlit_server = __jupyterpack_create_streamlit_app(\n            \"{{base_url}}\", \"{{script_path}}\"\n        )  # noqa\n        app = streamlit_server._create_app()\n        await streamlit_server._runtime.start()\n        __jupyterpack_streamlit_instance[\"streamlit_server\"] = streamlit_server\n        __jupyterpack_streamlit_instance[\"tornado_bridge\"] = TornadoBridge(\n            app, \"{{base_url}}\"\n        )\n\n    tornado_bridge = __jupyterpack_streamlit_instance[\"tornado_bridge\"]\n    req_dict = {\n        \"method\": method,\n        \"url\": url,\n        \"headers\": list(headers.items()),\n        \"body\": content,\n    }\n\n    response = await tornado_bridge.fetch(req_dict)\n    json_str = json.dumps(response)\n    return json_str\n";

package/lib/pythonServer/streamlit/generatedPythonFiles.js

@@ -0,0 +1,147 @@
+// Auto-generated TypeScript file from Python files
+export const bootstrap = `
+import os
+
+import threading
+import streamlit.watcher.path_watcher
+import contextlib
+import streamlit.elements.spinner
+
+os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
+
+
+class MockedThread(threading.Thread):
+    def start(self):
+        threading.current_thread = lambda: self
+        try:
+            self.run()
+        except Exception as e:
+            raise e
+
+
+threading.Thread = MockedThread
+
+
+class WatcherMock:
+    def __init__(
+        self,
+        path,
+        callback,
+        glob_pattern: str | None = None,
+        allow_nonexistent: bool = False,
+    ) -> None:
+        pass
+
+    def close(self) -> None:
+        pass
+
+
+streamlit.watcher.path_watcher.watchdog_available = False
+streamlit.watcher.path_watcher.EventBasedPathWatcher = WatcherMock
+streamlit.watcher.path_watcher._is_watchdog_available = lambda: False
+streamlit.watcher.path_watcher.get_path_watcher_class = lambda x: WatcherMock
+
+
+class MockThreading:
+    class Timer:
+        def __init__(self, delay, cb):
+            cb()
+
+        def start(self):
+            pass
+
+    Lock = contextlib.nullcontext
+
+
+streamlit.elements.spinner.threading = MockThreading
+`;
+export const streamlitLoader = `
+import json
+from streamlit import config
+import streamlit.web.server.server as st_server
+from streamlit.runtime.runtime import Runtime
+
+try:
+    # Check if __jupyterpack_streamlit_instance defined from previous run
+    __jupyterpack_streamlit_instance
+except NameError:
+    __jupyterpack_streamlit_instance = {
+        "tornado_bridge": None,
+        "streamlit_server": None,
+    }
+
+
+def __jupyterpack_create_streamlit_app(base_url, script_path):
+    if Runtime._instance is not None:
+        Runtime._instance.stop()
+        Runtime._instance = None
+    config.set_option("server.baseUrlPath", base_url)
+
+    config.set_option("server.port", 6789)
+    config.set_option("server.enableCORS", False)
+    config.set_option("server.enableXsrfProtection", False)
+
+    streamlit_server = st_server.Server(script_path, True)
+    return streamlit_server
+
+
+def __jupyterpack_streamlit_dispose():
+    global __jupyterpack_streamlit_instance
+    streamlit_server = __jupyterpack_streamlit_instance.get("streamlit_server", None)
+    if streamlit_server:
+        streamlit_server._runtime.stop()
+
+    __jupyterpack_streamlit_instance = {
+        "tornado_bridge": None,
+        "streamlit_server": None,
+    }
+    del streamlit_server
+
+
+async def __jupyterpack_streamlit_open_ws(
+    instance_id: str, kernel_client_id: str, ws_url: str, protocols_str: str | None
+):
+    tornado_bridge = __jupyterpack_streamlit_instance["tornado_bridge"]
+    if tornado_bridge is None:
+        raise Exception("Missing tornado instance")
+    await tornado_bridge.open_ws(instance_id, kernel_client_id, ws_url, protocols_str)
+
+
+async def __jupyterpack_streamlit_receive_ws_message(
+    instance_id: str, kernel_client_id: str, ws_url: str, payload_message: str
+):
+    tornado_bridge = __jupyterpack_streamlit_instance["tornado_bridge"]
+    if tornado_bridge is None:
+        raise Exception("Missing tornado instance")
+    await tornado_bridge.receive_ws_message_from_js(
+        instance_id, kernel_client_id, ws_url, payload_message
+    )
+
+
+async def __jupyterpack_streamlit_get_response(
+    method, url, headers, content=None, params=None
+):
+    global __jupyterpack_streamlit_instance
+    if not __jupyterpack_streamlit_instance["streamlit_server"]:
+        streamlit_server = __jupyterpack_create_streamlit_app(
+            "{{base_url}}", "{{script_path}}"
+        )  # noqa
+        app = streamlit_server._create_app()
+        await streamlit_server._runtime.start()
+        __jupyterpack_streamlit_instance["streamlit_server"] = streamlit_server
+        __jupyterpack_streamlit_instance["tornado_bridge"] = TornadoBridge(
+            app, "{{base_url}}"
+        )
+
+    tornado_bridge = __jupyterpack_streamlit_instance["tornado_bridge"]
+    req_dict = {
+        "method": method,
+        "url": url,
+        "headers": list(headers.items()),
+        "body": content,
+    }
+
+    response = await tornado_bridge.fetch(req_dict)
+    json_str = json.dumps(response)
+    return json_str
+`;

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

@@ -0,0 +1,33 @@
+import { IDict } from '../../type';
+import { KernelExecutor } from '../kernelExecutor';
+export declare class StreamlitServer extends KernelExecutor {
+    init(options: {
+        entryPath?: string;
+        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>;
+    private _GET_RESPONSE_FUNCTION;
+    private _OPEN_WEBSOCKET_FUNCTION;
+    private _SEND_WEBSOCKET_FUNCTION;
+}

package/lib/pythonServer/streamlit/streamlitServer.js

@@ -0,0 +1,55 @@
+import { stringOrNone } from '../../tools';
+import { JupyterPackFramework } from '../../type';
+import { patch, tools } from '../common/generatedPythonFiles';
+import { KernelExecutor } from '../kernelExecutor';
+import { bootstrap as tornadoBootstrap, tornadoBridge } from '../tornado/generatedPythonFiles';
+import { bootstrap, streamlitLoader } from './generatedPythonFiles';
+export class StreamlitServer extends KernelExecutor {
+    constructor() {
+        super(...arguments);
+        this._GET_RESPONSE_FUNCTION = '__jupyterpack_streamlit_get_response';
+        this._OPEN_WEBSOCKET_FUNCTION = '__jupyterpack_streamlit_open_ws';
+        this._SEND_WEBSOCKET_FUNCTION = '__jupyterpack_streamlit_receive_ws_message';
+    }
+    async init(options) {
+        await super.init(options);
+        const { instanceId, kernelClientId, entryPath } = options;
+        if (!entryPath) {
+            throw new Error('Missing streamlit entry path, please check your SPK file');
+        }
+        const baseURL = this.buildBaseURL({
+            instanceId,
+            kernelClientId,
+            framework: JupyterPackFramework.STREAMLIT
+        });
+        await this.executeCode({ code: patch });
+        await this.executeCode({ code: tools.replaceAll('{{base_url}}', baseURL) });
+        await this.executeCode({ code: tornadoBootstrap });
+        await this.executeCode({ code: tornadoBridge });
+        await this.executeCode({ code: bootstrap });
+        const stCode = streamlitLoader
+            .replaceAll('{{base_url}}', baseURL)
+            .replaceAll('{{script_path}}', entryPath);
+        await this.executeCode({ code: stCode });
+    }
+    getResponseFunctionFactory(options) {
+        const { method, urlPath, headers, params, content } = options;
+        const code = `await ${this._GET_RESPONSE_FUNCTION}("${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._OPEN_WEBSOCKET_FUNCTION}("${instanceId}", "${kernelId}", "${wsUrl}", ${stringOrNone(protocol)})`;
+        return code;
+    }
+    sendWebsocketMessageFunctionFactory(options) {
+        const { instanceId, kernelId, wsUrl, message } = options;
+        const code = `await ${this._SEND_WEBSOCKET_FUNCTION}("${instanceId}", "${kernelId}", "${wsUrl}", '''${message}''')`;
+        return code;
+    }
+    async disposePythonServer() {
+        await this.executeCode({
+            code: '__jupyterpack_streamlit_dispose()'
+        });
+    }
+}