jupyterpack 0.3.0 → 0.5.1

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

package/src/pythonServer/common/generatedPythonFiles.ts

@@ -1,73 +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/src/pythonServer/dash/generatedPythonFiles.ts

@@ -1,32 +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/src/pythonServer/streamlit/generatedPythonFiles.ts

@@ -1,148 +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
-`;