jupyterpack 0.2.1 → 0.3.0

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

@@ -0,0 +1,3 @@
+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";

package/lib/pythonServer/tornado/generatedPythonFiles.js

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

package/lib/pythonServer/tornado/tornadoServer.d.ts

@@ -0,0 +1,32 @@
+import { IDict } from '../../type';
+import { KernelExecutor } from '../kernelExecutor';
+export declare class TornadoServer 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;
+    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/tornado/tornadoServer.js

@@ -0,0 +1,51 @@
+import { stringOrNone } from '../../tools';
+import { JupyterPackFramework } from '../../type';
+import { tools } from '../common/generatedPythonFiles';
+import { KernelExecutor } from '../kernelExecutor';
+import { bootstrap, tornadoBridge, tornadoLoader } from './generatedPythonFiles';
+export class TornadoServer extends KernelExecutor {
+    constructor() {
+        super(...arguments);
+        this._GET_RESPONSE_FUNCTION = '__jupyterpack_tornado_get_response';
+        this._OPEN_WEBSOCKET_FUNCTION = '__jupyterpack_tornado_open_ws';
+        this._SEND_WEBSOCKET_FUNCTION = '__jupyterpack_tornado_receive_ws_message';
+    }
+    async init(options) {
+        await super.init(options);
+        const { initCode, instanceId, kernelClientId } = options;
+        const baseURL = this.buildBaseURL({
+            instanceId,
+            kernelClientId,
+            framework: JupyterPackFramework.TORNADO
+        });
+        await this.executeCode({ code: tools.replaceAll('{{base_url}}', baseURL) });
+        await this.executeCode({ code: bootstrap });
+        await this.executeCode({ code: tornadoBridge });
+        if (initCode) {
+            const initCodeWithUrl = initCode.replaceAll('{{base_url}}', baseURL);
+            await this.executeCode({ code: initCodeWithUrl });
+            const torCode = tornadoLoader.replaceAll('{{base_url}}', baseURL);
+            await this.executeCode({ code: torCode });
+        }
+    }
+    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_tornado_dispose()'
+        });
+    }
+}

package/lib/pythonWidget/pythonWidget.d.ts

@@ -3,6 +3,7 @@ import { IFramePanel } from '../document/iframePanel';
 export declare class PythonWidget extends IFramePanel {
     constructor(options: PythonWidget.IOptions);
     get model(): PythonWidgetModel;
+    dispose(): void;
     private _model;
 }
 export declare namespace PythonWidget {

package/lib/pythonWidget/pythonWidget.js

@@ -1,16 +1,19 @@
-import { PageConfig } from '@jupyterlab/coreutils';
+import { PageConfig, URLExt } from '@jupyterlab/coreutils';
 import { IFramePanel } from '../document/iframePanel';
 export class PythonWidget extends IFramePanel {
     constructor(options) {
         super();
         this._model = options.model;
         this._model.initialize().then(connectionData => {
-            if (!connectionData) {
+            if (!connectionData.success) {
+                this.toggleSpinner(false);
+                this._iframe.contentDocument.body.innerText = `Failed to start server: ${connectionData.error}`;
                 return;
             }
             const iframe = this._iframe;
             const fullLabextensionsUrl = PageConfig.getOption('fullLabextensionsUrl');
-            iframe.src = `${fullLabextensionsUrl}/jupyterpack/static/${connectionData.instanceId}/dash/${connectionData.kernelClientId}/`;
+            const iframeUrl = URLExt.join(fullLabextensionsUrl, 'jupyterpack/static', connectionData.instanceId, connectionData.framework, connectionData.kernelClientId, connectionData.rootUrl);
+            iframe.src = iframeUrl;
             iframe.addEventListener('load', () => {
                 this.toggleSpinner(false);
             });
@@ -19,4 +22,7 @@ export class PythonWidget extends IFramePanel {
     get model() {
         return this._model;
     }
+    dispose() {
+        this._model.dispose();
+    }
 }

package/lib/pythonWidget/pythonWidgetModel.d.ts

@@ -1,15 +1,21 @@
 import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { Contents, ServiceManager } from '@jupyterlab/services';
 import { IDisposable } from '@lumino/disposable';
-import { ServiceManager, Contents } from '@jupyterlab/services';
-import { IConnectionManager } from '../type';
+import { IConnectionManager, IJupyterPackFileFormat, JupyterPackFramework } from '../type';
 export declare class PythonWidgetModel implements IDisposable {
     constructor(options: PythonWidgetModel.IOptions);
     get isDisposed(): boolean;
     get connectionManager(): IConnectionManager;
     initialize(): Promise<{
+        success: true;
         instanceId: string;
         kernelClientId: string;
-    } | null>;
+        rootUrl: string;
+        framework: JupyterPackFramework;
+    } | {
+        success: false;
+        error: string;
+    }>;
     dispose(): void;
     private _isDisposed;
     private _kernelStarted;
@@ -18,9 +24,12 @@ export declare class PythonWidgetModel implements IDisposable {
     private _context;
     private _connectionManager;
     private _contentsManager;
+    private _jpackModel;
+    private _executor?;
 }
 export declare namespace PythonWidgetModel {
     interface IOptions {
+        jpackModel: IJupyterPackFileFormat;
         context: DocumentRegistry.IContext<DocumentRegistry.IModel>;
         manager: ServiceManager.IManager;
         connectionManager: IConnectionManager;