jupyterpack 0.3.0 → 0.5.1

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/pythonServer/common/generatedPythonFiles.d.ts

@@ -1,2 +0,0 @@
-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

@@ -1,72 +0,0 @@
-// 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/generatedPythonFiles.d.ts

@@ -1,2 +0,0 @@
-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

@@ -1,31 +0,0 @@
-// 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/streamlit/generatedPythonFiles.d.ts

@@ -1,2 +0,0 @@
-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

@@ -1,147 +0,0 @@
-// 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/tornado/generatedPythonFiles.d.ts

@@ -1,3 +0,0 @@
-export declare const bootstrap = "\nimport sys\n\nif \"tornado.gen\" in sys.modules:\n    del sys.modules[\"tornado.gen\"]\n\ntornado = __jupyterpack_import_from_path(\n    \"tornado\", \"/lib/python3.13/site-packages/tornado/__init__.py\"\n)\n";
-export declare const tornadoBridge = "\nimport asyncio\nimport base64\nimport json\nimport logging\nimport tornado\n\nfrom tornado.http1connection import HTTP1Connection, HTTP1ConnectionParameters\nfrom tornado.iostream import BaseIOStream, IOStream\nfrom tornado.httputil import HTTPHeaders, RequestStartLine, HTTPServerRequest\nfrom tornado.websocket import WebSocketHandler\nimport tornado.escape\nimport pyjs\nfrom typing import Any, Dict, List, Optional, Tuple\n\n\nlogger = logging.getLogger(__name__)\nlogger.setLevel(logging.WARN)\n\n\ndef convert_headers(\n    headers: List[Tuple[str, str]],\n) -> HTTPHeaders:\n    tornado_headers = HTTPHeaders()\n    for k, v in headers:\n        tornado_headers.add(k, v)\n    return tornado_headers\n\n\ndef encode_broadcast_message(\n    kernel_client_id: str,\n    ws_url: str,\n    msg: str | bytes,\n    action: str = \"backend_message\",\n):\n    if isinstance(msg, bytes):\n        is_binary = True\n        b64_msg = base64.b64encode(msg).decode(\"ascii\")\n    elif isinstance(msg, str):\n        is_binary = False\n        b64_msg = msg\n\n    return json.dumps(\n        {\n            \"action\": action,\n            \"dest\": kernel_client_id,\n            \"wsUrl\": ws_url,\n            \"payload\": {\"isBinary\": is_binary, \"data\": b64_msg},\n        }\n    )\n\n\ndef decode_broadcast_message(payload_message: str):\n    msg_object = json.loads(payload_message)\n    is_binary = msg_object[\"isBinary\"]\n    data = msg_object[\"data\"]\n    if is_binary:\n        return base64.b64decode(data)\n    else:\n        return data\n\n\nclass DumpStream(BaseIOStream):\n    max_buffer_size = 1048576000\n\n    def close_fd(*args, **kwargs):\n        pass\n\n    def write_to_fd(self, buf):\n        raise NotImplementedError(\"Not supported!\")\n\n\nclass ConnectionState:\n    def __init__(self):\n        self._reply_body = b\"\"\n        self._finish_future = asyncio.Future()\n        self._reply_headers = []\n        self._status: Optional[int] = None\n\n    @property\n    def reply_body(self):\n        return base64.b64encode(self._reply_body).decode(\"ascii\")\n\n    @property\n    def reply_headers(self):\n        reply_headers = json.dumps(dict(self._reply_headers)).encode(\"utf-8\")\n        return base64.b64encode(reply_headers).decode(\"ascii\")\n\n    @property\n    def status(self):\n        return self._status\n\n    @property\n    def finish_future(self):\n        return self._finish_future\n\n    def append_reply_body(self, chunk: bytes):\n        self._reply_body += chunk\n\n    def append_reply_header(self, headers: List[Tuple[str, str]]):\n        self._reply_headers.extend(headers)\n\n    def set_status(self, status: int):\n        self._status = status\n\n    def finish(self):\n        self._finish_future.set_result(None)\n\n\nclass PatchedConnection(HTTP1Connection):\n    def __init__(\n        self,\n        stream: IOStream,\n        is_client: bool,\n        params: Optional[HTTP1ConnectionParameters] = None,\n        context: Optional[object] = None,\n        initial_request_data: Optional[Dict] = None,\n    ) -> None:\n        super().__init__(stream, is_client, params, context)\n        self._connection_state = ConnectionState()\n        if initial_request_data is not None:\n            self._request_start_line = RequestStartLine(\n                initial_request_data.get(\"request_method\"),\n                initial_request_data.get(\"request_url\"),\n                \"HTTP/1.1\",\n            )\n\n    @property\n    def connection_state(self):\n        return self._connection_state\n\n    def write(self, chunk: bytes):\n        self._connection_state.append_reply_body(chunk)\n        f = asyncio.Future()\n        f.set_result(None)\n        return f\n\n    def write_headers(self, start_line, headers, chunk=None):\n        self._connection_state.set_status(int(start_line.code))\n        self._connection_state.append_reply_header(headers.get_all())\n        if chunk is not None:\n            self._connection_state.append_reply_body(chunk)\n        f = asyncio.Future()\n        f.set_result(None)\n        return f\n\n    def finish(self):\n        self._connection_state.finish()\n\n\nclass WSConnection:\n    def __init__(\n        self,\n        instance_id: str,\n        kernel_client_id: str,\n        ws_url: str,\n        broadcast_channel: Any,\n    ):\n        self.instance_id = instance_id\n        self.kernel_client_id = kernel_client_id\n        self.ws_url = ws_url\n        self.broadcast_channel = broadcast_channel\n\n    client_terminated = False\n\n    def is_closing(self):\n        return False\n\n    def write_message(self, msg, binary=False):\n        if isinstance(msg, dict):\n            msg = tornado.escape.json_encode(msg)\n        self.broadcast_channel.postMessage(\n            encode_broadcast_message(self.kernel_client_id, self.ws_url, msg)\n        )\n        f = asyncio.Future()\n        f.set_result(None)\n        return f\n\n    def write_ping(self, data):\n        pass\n\n    def close(self, code, reason=None):\n        pass\n\n\nclass TornadoBridge:\n    \"\"\"\n    Encapsulates Tornado app lifecycle, request/response bridging, and WebSocket handling.\n    \"\"\"\n\n    def __init__(self, tornado_app: tornado.web.Application, base_url: str):\n        self.base_url = base_url\n        self.tornado_app = tornado_app\n        self.websocket_handlers: Dict[str, tornado.websocket.WebSocketHandler] = {}\n        self._patched = False\n        self._ws_handlers = {}\n        self._ws_broadcast_channels = {}\n\n    # ---------------------------\n    # Fetch Handling\n    # ---------------------------\n\n    async def fetch(self, request: Dict):\n        \"\"\"\n        request: {body: Optional[bytes], headers: List[Tuple[str, str]], method: str, url: str}\n        \"\"\"\n\n        request_headers = convert_headers(request.get(\"headers\", []))\n        request_method = request.get(\"method\", \"GET\").upper()\n        request_url: str = request.get(\"url\", \"/\")\n\n        request_body = request.get(\"body\", None)\n        stream = DumpStream()\n\n        connection = PatchedConnection(\n            stream,\n            is_client=False,\n            params=None,\n            context=None,\n            initial_request_data={\n                \"request_method\": request_method,\n                \"request_url\": request_url,\n            },\n        )\n\n        request = HTTPServerRequest(\n            method=request_method,\n            uri=request_url,\n            headers=request_headers,\n            body=request_body,\n            connection=connection,\n        )\n        try:\n            handler = self.tornado_app.find_handler(request)\n            handler.execute()\n            connection_state = connection.connection_state\n            await connection_state.finish_future\n\n            return {\n                \"content\": connection_state.reply_body,\n                \"headers\": connection_state.reply_headers,\n                \"status_code\": connection_state.status,\n            }\n        except Exception as e:\n            return {\n                \"headers\": \"e30=\",  # {}\n                \"content\": base64.b64encode(str(e).encode(\"utf-8\")).decode(\"ascii\"),\n                \"status_code\": 500,\n            }\n\n    # ---------------------------\n    # Websocket Handling\n    # ---------------------------\n    async def open_ws(\n        self,\n        instance_id: str,\n        kernel_client_id: str,\n        ws_url: str,\n        protocols_str: str | None,\n    ):\n        handler_key = f\"{instance_id}@{kernel_client_id}@{ws_url}\"\n        broadcast_channel = self._ws_broadcast_channels.get(handler_key, None)\n\n        if broadcast_channel is None:\n            broadcast_channel = pyjs.js.BroadcastChannel.new(\n                f\"/jupyterpack/ws/{instance_id}\"\n            )\n            self._ws_broadcast_channels[handler_key] = broadcast_channel\n\n        headers = convert_headers(\n            [\n                (\"X-Sec-WebSocket-Protocol\", protocols_str),\n                (\"Upgrade\", \"websocket\"),\n                (\"Connection\", \"Upgrade\"),\n                (\"Sec-WebSocket-Key\", \"\"),\n                (\"Sec-WebSocket-Version\", \"13\"),\n            ]\n        )\n        protocols = []\n        if protocols_str is not None:\n            protocols = protocols_str.split(\",\")\n\n        stream = DumpStream()\n        ws_connection = WSConnection(\n            instance_id, kernel_client_id, ws_url, broadcast_channel\n        )\n        connection = PatchedConnection(\n            stream,\n            is_client=False,\n            params=None,\n            context=None,\n            initial_request_data={\n                \"request_method\": \"GET\",\n                \"request_url\": ws_url,\n            },\n        )\n\n        request = tornado.httputil.HTTPServerRequest(\n            method=\"GET\",\n            uri=ws_url,\n            headers=headers,\n            body=None,\n            connection=connection,\n        )\n\n        handler = self.tornado_app.find_handler(request)\n        ret = handler.execute()\n        if ret is not None:\n            await ret\n        connection_state = connection.connection_state\n        await connection_state.finish_future\n\n        if isinstance(handler.handler, WebSocketHandler):\n            handler.handler.select_subprotocol(protocols)\n            handler.handler.ws_connection = ws_connection\n            ret = handler.handler.open(\n                *handler.handler.open_args, **handler.handler.open_kwargs\n            )\n            if ret is not None:\n                try:\n                    await ret\n                except Exception:\n                    raise (\"Failed to open websocket\")\n\n        self._ws_handlers[handler_key] = handler\n\n        self.send_ws_message_to_js(\n            instance_id, kernel_client_id, ws_url, \"\", \"connected\"\n        )\n\n    def send_ws_message_to_js(\n        self,\n        instance_id: str,\n        kernel_client_id: str,\n        ws_url: str,\n        msg: str | bytes,\n        action: str = \"backend_message\",\n    ):\n        handler_key = f\"{instance_id}@{kernel_client_id}@{ws_url}\"\n        broadcast_channel = self._ws_broadcast_channels.get(handler_key, None)\n        if broadcast_channel is not None:\n            broadcast_channel.postMessage(\n                encode_broadcast_message(kernel_client_id, ws_url, msg, action)\n            )\n\n    async def receive_ws_message_from_js(\n        self, instance_id: str, kernel_client_id: str, ws_url: str, payload_message: str\n    ):\n        handler_key = f\"{instance_id}@{kernel_client_id}@{ws_url}\"\n        handler = self._ws_handlers.get(handler_key, None)\n        if handler is not None:\n            data = decode_broadcast_message(payload_message)\n            future = handler.handler.on_message(data)\n            if future is not None:\n                await future\n";
-export declare const tornadoLoader = "\nimport base64\nimport json\n\ntry:\n    # Check if __jupyterpack_tornado_instance defined from previous run\n    __jupyterpack_tornado_instance\nexcept NameError:\n    __jupyterpack_tornado_instance = {\n        \"tornado_bridge\": None,\n        \"tornado_server\": None,\n    }\n\ndef __jupyterpack_tornado_dispose():\n    global __jupyterpack_tornado_instance\n    __jupyterpack_tornado_instance = {\n        \"tornado_bridge\": None,\n        \"tornado_server\": None,\n    }\n\n\n\nasync def __jupyterpack_tornado_open_ws(\n    instance_id: str, kernel_client_id: str, ws_url: str, protocols_str: str | None\n):\n    tornado_bridge = __jupyterpack_tornado_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_tornado_receive_ws_message(\n    instance_id: str, kernel_client_id: str, ws_url: str, payload_message: str\n):\n    tornado_bridge = __jupyterpack_tornado_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_tornado_get_response(\n    method, url, headers, content=None, params=None\n):\n    global __jupyterpack_tornado_instance\n    if __jupyterpack_tornado_instance[\"tornado_server\"] is None:\n        __jupyterpack_tornado_instance[\"tornado_server\"] = app # noqa\n        __jupyterpack_tornado_instance[\"tornado_bridge\"] = TornadoBridge( # noqa\n            app, \"{{base_url}}\" # noqa\n        )\n\n    tornado_bridge = __jupyterpack_tornado_instance[\"tornado_bridge\"]\n    req_dict = {\n        \"method\": method,\n        \"url\": url,\n        \"headers\": list(headers.items()),\n        \"body\": content,\n    }\n\n    try:\n        res_body, res_headers, res_status = await tornado_bridge.fetch(req_dict)\n        response = {\n            \"headers\": dict(res_headers),\n            \"content\": res_body,\n            \"status_code\": res_status,\n            \"original_request\": {\n                \"method\": method,\n                \"url\": url,\n                \"params\": params,\n                \"headers\": headers,\n            },\n        }\n    except Exception as e:\n        response = {\n            \"headers\": {},\n            \"content\": str(e),\n            \"status_code\": 500,\n            \"original_request\": {\n                \"method\": method,\n                \"url\": url,\n                \"params\": params,\n                \"headers\": headers,\n            },\n        }\n    json_str = json.dumps(response)\n    b64_str = base64.b64encode(json_str.encode(\"utf-8\")).decode(\"utf-8\")\n    return b64_str\n";