jupyterpack 0.3.0 → 0.4.0

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

package/lib/pythonServer/tornado/generatedPythonFiles.js

@@ -1,456 +0,0 @@
-// 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
-`;