txl_remote_kernels 0.1.5__tar.gz → 0.2.4__tar.gz

txl_remote_kernels-0.2.4/.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+# pixi environments
+.pixi

{txl_remote_kernels-0.1.5 → txl_remote_kernels-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: txl_remote_kernels
-Version: 0.1.5
+Version: 0.2.4
 Summary: TXL plugin for remote kernels
 Project-URL: Source, https://github.com/davidbrochart/jpterm/plugins/remote_kernels
 Author-email: David Brochart <david.brochart@gmail.com>
@@ -8,19 +8,17 @@ License-Expression: MIT
 License-File: LICENSE.txt
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.7
-Requires-Dist: httpx-ws>=0.2.6
+Requires-Python: >=3.10
+Requires-Dist: httpx-ws>=0.4.2
 Requires-Dist: httpx>=0.23.1
-Requires-Dist: python-dateutil>=2.8.2
+Requires-Dist: pycrdt<0.8.0,>=0.7.2
 Requires-Dist: txl
-Requires-Dist: y-py>=0.5.5
+Requires-Dist: txl-kernel
 Description-Content-Type: text/markdown
 
 # TXL plugin for remote kernels

{txl_remote_kernels-0.1.5 → txl_remote_kernels-0.2.4}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 name = "txl_remote_kernels"
 description = "TXL plugin for remote kernels"
 readme = "README.md"
-requires-python = ">=3.7"
+requires-python = ">=3.10"
 license = "MIT"
 keywords = []
 authors = [
@@ -15,28 +15,27 @@ authors = [
 classifiers = [
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.7",
-  "Programming Language :: Python :: 3.8",
-  "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
   "txl",
-  "python-dateutil >=2.8.2",
+  "txl_kernel",
   "httpx >=0.23.1",
-  "httpx-ws >=0.2.6",
-  "y_py >=0.5.5",
+  "httpx-ws >=0.4.2",
+  "pycrdt >=0.7.2,<0.8.0",
 ]
 dynamic = ["version"]
 
 [project.urls]
 Source = "https://github.com/davidbrochart/jpterm/plugins/remote_kernels"
 
-[project.entry-points.txl_component]
-txl_remote_kernels = "txl_remote_kernels.components"
+[project.entry-points]
+"asphalt.components" = {remote_kernels = "txl_remote_kernels.components:RemoteKernelsComponent", remote_kernelspecs = "txl_remote_kernels.components:RemoteKernelspecsComponent"}
+"txl.components"     = {remote_kernels = "txl_remote_kernels.components:RemoteKernelsComponent", remote_kernelspecs = "txl_remote_kernels.components:RemoteKernelspecsComponent"}
 
 [tool.hatch.version]
 path = "txl_remote_kernels/__init__.py"

txl_remote_kernels-0.2.4/txl_remote_kernels/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.4"

txl_remote_kernels-0.2.4/txl_remote_kernels/components.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib import parse
+
+import httpx
+from asphalt.core import Component, Context
+from pycrdt import Map
+
+from txl.base import Kernels, Kernelspecs
+
+from .driver import KernelDriver
+
+
+class RemoteKernels(Kernels):
+    comm_handlers = []
+
+    def __init__(
+        self,
+        url: str,
+        kernel_name: str | None,
+    ):
+        self.kernel = KernelDriver(url, kernel_name, comm_handlers=self.comm_handlers)
+
+    async def execute(self, ycell: Map):
+        await self.kernel.execute(ycell)
+
+
+class RemoteKernelspecs(Kernelspecs):
+    def __init__(
+        self,
+        url: str,
+    ):
+        parsed_url = parse.urlparse(url)
+        self.base_url = parse.urljoin(url, parsed_url.path).rstrip("/")
+        self.query_params = parse.parse_qs(parsed_url.query)
+        self.cookies = httpx.Cookies()
+
+    async def get(self) -> dict[str, Any]:
+        url = f"{self.base_url}/api/kernelspecs"
+        try:
+            async with httpx.AsyncClient() as client:
+                r = await client.get(
+                    url,
+                    params={**self.query_params},
+                    cookies=self.cookies,
+                )
+                d = r.json()
+                self.cookies.update(r.cookies)
+                return d
+        except httpx.ConnectError:
+            raise RuntimeError(f"Could not connect to a Jupyter server at {url}")
+
+
+class RemoteKernelsComponent(Component):
+    def __init__(self, url: str = "http://127.0.0.1:8000"):
+        super().__init__()
+        self.url = url
+
+    async def start(
+        self,
+        ctx: Context,
+    ) -> None:
+        url = self.url
+
+        class _RemoteKernels(RemoteKernels):
+            def __init__(self, *args, **kwargs):
+                super().__init__(url, *args, **kwargs)
+
+        ctx.add_resource(_RemoteKernels, types=Kernels)
+
+
+class RemoteKernelspecsComponent(Component):
+    def __init__(self, url: str = "http://127.0.0.1:8000"):
+        super().__init__()
+        self.url = url
+
+    async def start(
+        self,
+        ctx: Context,
+    ) -> None:
+        kernelspecs = RemoteKernelspecs(self.url)
+        ctx.add_resource(kernelspecs, types=Kernelspecs)

txl_remote_kernels-0.2.4/txl_remote_kernels/driver.py

@@ -0,0 +1,121 @@
+import asyncio
+import json
+import time
+import uuid
+from typing import Any, Dict
+from urllib import parse
+
+import httpx
+from httpx_ws import aconnect_ws
+from txl_kernel.driver import KernelMixin
+from txl_kernel.message import date_to_str
+
+from .message import (
+    deserialize_msg_from_ws_v1,
+    from_binary,
+    serialize_msg_to_ws_v1,
+    to_binary,
+)
+
+
+def deadline_to_timeout(deadline: float) -> float:
+    return max(0, deadline - time.time())
+
+
+class KernelDriver(KernelMixin):
+    def __init__(
+        self,
+        url: str,
+        kernel_name: str | None = "",
+        comm_handlers=[],
+    ) -> None:
+        super().__init__()
+        self.kernel_name = kernel_name
+        parsed_url = parse.urlparse(url)
+        self.base_url = parse.urljoin(url, parsed_url.path).rstrip("/")
+        self.query_params = parse.parse_qs(parsed_url.query)
+        self.cookies = httpx.Cookies()
+        i = self.base_url.find(":")
+        self.ws_url = ("wss" if self.base_url[i - 1] == "s" else "ws") + self.base_url[i:]
+        self.start_task = asyncio.create_task(self.start())
+        self.comm_handlers = comm_handlers
+        self.shell_channel = "shell"
+        self.control_channel = "control"
+        self.iopub_channel = "iopub"
+        self.send_lock = asyncio.Lock()
+        self.kernel_id = None
+
+    async def start(self):
+        i = str(uuid.uuid4())
+        async with httpx.AsyncClient() as client:
+            body = {
+                "kernel": {"name": self.kernel_name},
+                "name": i,
+                "path": i,
+                "type": "notebook",
+            }
+            r = await client.post(
+                f"{self.base_url}/api/sessions",
+                json=body,
+                params={**self.query_params},
+                cookies=self.cookies,
+            )
+            d = r.json()
+            self.cookies.update(r.cookies)
+            self.session_id = d["id"]
+            self.kernel_id = d["kernel"]["id"]
+            r = await client.get(
+                f"{self.base_url}/api/kernels/{self.kernel_id}",
+                cookies=self.cookies,
+            )
+        if r.status_code != 200 or self.kernel_id != r.json()["id"]:
+            return
+        async with aconnect_ws(
+            f"{self.ws_url}/api/kernels/{self.kernel_id}/channels",
+            params={"session_id": self.session_id},
+            cookies=self.cookies,
+            subprotocols=["v1.kernel.websocket.jupyter.org"],
+        ) as self.websocket:
+            recv_task = asyncio.create_task(self._recv())
+            try:
+                await self.wait_for_ready()
+                self.started.set()
+                await asyncio.Future()
+            except BaseException:
+                recv_task.cancel()
+                self.start_task.cancel()
+
+    async def _recv(self):
+        while True:
+            message = await self.websocket.receive()
+            if self.websocket.subprotocol == "v1.kernel.websocket.jupyter.org":
+                msg = deserialize_msg_from_ws_v1(message.data)
+            else:
+                if isinstance(message.data, str):
+                    msg = json.loads(message.data)
+                else:
+                    msg = from_binary(message.data)
+            self.recv_queue.put_nowait(msg)
+
+    async def send_message(
+        self,
+        msg: Dict[str, Any],
+        channel,
+        change_date_to_str: bool = False,
+    ):
+        async with self.send_lock:
+            _date_to_str = date_to_str if change_date_to_str else lambda x: x
+            msg["header"] = _date_to_str(msg["header"])
+            msg["parent_header"] = _date_to_str(msg["parent_header"])
+            msg["metadata"] = _date_to_str(msg["metadata"])
+            msg["content"] = _date_to_str(msg.get("content", {}))
+            msg["channel"] = channel
+            if self.websocket.subprotocol == "v1.kernel.websocket.jupyter.org":
+                bmsg = serialize_msg_to_ws_v1(msg)
+                await self.websocket.send_bytes(bmsg)
+            else:
+                bmsg = to_binary(msg)
+                if bmsg is None:
+                    await self.websocket.send_json(msg)
+                else:
+                    await self.websocket.send_bytes(bmsg)

txl_remote_kernels-0.2.4/txl_remote_kernels/message.py

@@ -0,0 +1,67 @@
+import json
+import struct
+from typing import Any, Dict, List, Optional
+
+
+def deserialize_msg_from_ws_v1(ws_msg: bytes) -> Dict[str, Any]:
+    offset_number = int.from_bytes(ws_msg[:8], "little")
+    offsets = [
+        int.from_bytes(ws_msg[8 * (i + 1) : 8 * (i + 2)], "little") for i in range(offset_number)
+    ]
+    channel = ws_msg[offsets[0] : offsets[1]].decode("utf-8")
+    msg_list = [ws_msg[offsets[i] : offsets[i + 1]] for i in range(1, offset_number - 1)]
+    msg = {
+        "channel": channel,
+        "header": json.loads(msg_list[0]),
+        "parent_header": json.loads(msg_list[1]),
+        "metadata": json.loads(msg_list[2]),
+        "content": json.loads(msg_list[3]),
+    }
+    msg["buffers"] = msg_list[4:]
+    return msg
+
+
+def serialize_msg_to_ws_v1(msg: Dict[str, Any]) -> List[bytes]:
+    msg_list = [
+        json.dumps(msg["header"]).encode("utf-8"),
+        json.dumps(msg["parent_header"]).encode("utf-8"),
+        json.dumps(msg["metadata"]).encode("utf-8"),
+        json.dumps(msg["content"]).encode("utf-8"),
+    ] + msg.get("buffers", [])
+    channel_b = msg["channel"].encode("utf-8")
+    offsets = []
+    offsets.append(8 * (1 + 1 + len(msg_list) + 1))
+    offsets.append(len(channel_b) + offsets[-1])
+    for msg in msg_list:
+        offsets.append(len(msg) + offsets[-1])
+    offset_number = len(offsets).to_bytes(8, byteorder="little")
+    offsets_b = [offset.to_bytes(8, byteorder="little") for offset in offsets]
+    bin_msg = [offset_number] + offsets_b + [channel_b] + msg_list
+    return b"".join(bin_msg)
+
+
+def to_binary(msg: Dict[str, Any]) -> Optional[bytes]:
+    if not msg["buffers"]:
+        return None
+    buffers = msg.pop("buffers")
+    bmsg = json.dumps(msg).encode("utf8")
+    buffers.insert(0, bmsg)
+    n = len(buffers)
+    offsets = [4 * (n + 1)]
+    for b in buffers[:-1]:
+        offsets.append(offsets[-1] + len(b))
+    header = struct.pack("!" + "I" * (n + 1), n, *offsets)
+    buffers.insert(0, header)
+    return b"".join(buffers)
+
+
+def from_binary(bmsg: bytes) -> Dict[str, Any]:
+    n = struct.unpack("!i", bmsg[:4])[0]
+    offsets = list(struct.unpack("!" + "I" * n, bmsg[4 : 4 * (n + 1)]))  # noqa
+    offsets.append(None)
+    buffers = []
+    for start, stop in zip(offsets[:-1], offsets[1:]):
+        buffers.append(bmsg[start:stop])
+    msg = json.loads(buffers[0].decode("utf8"))
+    msg["buffers"] = buffers[1:]
+    return msg

txl_remote_kernels-0.1.5/.gitignore

@@ -1 +0,0 @@
-__pycache__

txl_remote_kernels-0.1.5/txl_remote_kernels/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.5"

txl_remote_kernels-0.1.5/txl_remote_kernels/components.py

@@ -1,37 +0,0 @@
-from functools import partial
-
-import y_py as Y
-from asphalt.core import Component, Context
-
-from txl.base import Kernels
-from txl.hooks import register_component
-
-from .driver import KernelDriver
-
-
-class RemoteKernels(Kernels):
-    def __init__(
-        self,
-        url: str,
-        kernel_name: str,
-    ):
-        self.kernel = KernelDriver(url, kernel_name)
-
-    async def execute(self, ydoc: Y.YDoc, ycell: Y.YMap):
-        await self.kernel.execute(ydoc, ycell)
-
-
-class RemoteKernelsComponent(Component):
-    def __init__(self, url: str = "http://127.0.0.1:8000"):
-        super().__init__()
-        self.url = url
-
-    async def start(
-        self,
-        ctx: Context,
-    ) -> None:
-        terminals_factory = partial(RemoteKernels, self.url)
-        ctx.add_resource(terminals_factory, name="kernels", types=Kernels)
-
-
-c = register_component("kernels", RemoteKernelsComponent)

txl_remote_kernels-0.1.5/txl_remote_kernels/driver.py

@@ -1,237 +0,0 @@
-import asyncio
-import time
-import uuid
-from typing import Dict, List
-from urllib import parse
-
-import httpx
-import y_py as Y
-from httpx_ws import WebSocketNetworkError, aconnect_ws
-
-from .message import create_message, send_message, str_to_date
-
-
-def deadline_to_timeout(deadline: float) -> float:
-    return max(0, deadline - time.time())
-
-
-class KernelDriver:
-    def __init__(
-        self,
-        url: str,
-        kernel_name: str = "",
-    ) -> None:
-        self.kernel_name = kernel_name
-        parsed_url = parse.urlparse(url)
-        self.base_url = parse.urljoin(url, parsed_url.path).rstrip("/")
-        self.query_params = parse.parse_qs(parsed_url.query)
-        self.cookies = httpx.Cookies()
-        i = self.base_url.find(":")
-        self.ws_url = ("wss" if self.base_url[i - 1] == "s" else "ws") + self.base_url[
-            i:
-        ]
-        self.msg_cnt = 0
-        self.execute_requests: Dict[str, Dict[str, List[asyncio.Future]]] = {}
-        self.started = asyncio.Event()
-        self.start_task = asyncio.create_task(self.start())
-
-    async def start(self):
-        i = str(uuid.uuid4())
-        async with httpx.AsyncClient() as client:
-            body = {
-                "kernel": {"name": self.kernel_name},
-                "name": i,
-                "path": i,
-                "type": "notebook",
-            }
-            r = await client.post(
-                f"{self.base_url}/api/sessions",
-                json=body,
-                params={**self.query_params},
-                cookies=self.cookies,
-            )
-            response = r.json()
-            self.cookies.update(r.cookies)
-            self.session_id = response["id"]
-            kernel_id = response["kernel"]["id"]
-            response = await client.get(
-                f"{self.base_url}/api/kernels/{kernel_id}",
-                cookies=self.cookies,
-            )
-        if response.status_code != 200 or kernel_id != response.json()["id"]:
-            return
-        async with aconnect_ws(
-            f"{self.ws_url}/api/kernels/{kernel_id}/channels",
-            params={"session_id": self.session_id},
-            cookies=self.cookies,
-        ) as self.websocket:
-            recv_task = asyncio.create_task(self._recv())
-            try:
-                await self._wait_for_ready()
-                await asyncio.Future()
-            except BaseException:
-                recv_task.cancel()
-                self.start_task.cancel()
-
-    async def _recv(self):
-        try:
-            while True:
-                message = await self.websocket.receive_json()
-                channel = message.pop("channel")
-                message["header"] = str_to_date(message["header"])
-                message["parent_header"] = str_to_date(message["parent_header"])
-                msg_id = message["parent_header"].get("msg_id")
-                if msg_id in self.execute_requests:
-                    future_messages = self.execute_requests[msg_id][channel]
-                    if future_messages:
-                        fut = future_messages[-1]
-                        if fut.done():
-                            fut = asyncio.Future()
-                            future_messages.append(fut)
-                    else:
-                        fut = asyncio.Future()
-                        future_messages.append(fut)
-                    fut.set_result(message)
-        except WebSocketNetworkError:
-            pass
-
-    async def _wait_for_ready(self, timeout: float = float("inf")):
-        deadline = time.time() + timeout
-        new_timeout = timeout
-        while True:
-            msg = create_message(
-                "kernel_info_request",
-                session_id=self.session_id,
-                msg_id=str(self.msg_cnt),
-            )
-            self.msg_cnt += 1
-            await send_message(msg, "shell", self.websocket, change_date_to_str=True)
-            msg_id = msg["header"]["msg_id"]
-            self.execute_requests[msg_id] = {
-                "iopub": [asyncio.Future()],
-                "shell": [asyncio.Future()],
-            }
-            try:
-                msg = await asyncio.wait_for(
-                    self.execute_requests[msg_id]["shell"][0], new_timeout
-                )
-            except asyncio.TimeoutError:
-                del self.execute_requests[msg_id]
-                error_message = f"Kernel didn't respond in {timeout} seconds"
-                raise RuntimeError(error_message)
-            if msg["header"]["msg_type"] == "kernel_info_reply":
-                try:
-                    msg = await asyncio.wait_for(
-                        self.execute_requests[msg_id]["iopub"][0], 0.2
-                    )
-                except asyncio.TimeoutError:
-                    pass
-                else:
-                    break
-            del self.execute_requests[msg_id]
-            new_timeout = deadline_to_timeout(deadline)
-        self.started.set()
-
-    async def execute(
-        self,
-        ydoc: Y.YDoc,
-        ycell: Y.YMap,
-        timeout: float = float("inf"),
-        msg_id: str = "",
-        wait_for_executed: bool = True,
-    ) -> None:
-        await self.started.wait()
-        if ycell["cell_type"] != "code":
-            return
-        code = str(ycell["source"])
-        content = {"code": code, "silent": False}
-        msg = create_message(
-            "execute_request",
-            content,
-            session_id=self.session_id,
-            msg_id=str(self.msg_cnt),
-        )
-        if msg_id:
-            msg["header"]["msg_id"] = msg_id
-        else:
-            msg_id = msg["header"]["msg_id"]
-        self.msg_cnt += 1
-        await send_message(msg, "shell", self.websocket, change_date_to_str=True)
-        if wait_for_executed:
-            deadline = time.time() + timeout
-            self.execute_requests[msg_id] = {
-                "iopub": [asyncio.Future()],
-                "shell": [asyncio.Future()],
-            }
-            try:
-                await asyncio.wait_for(
-                    self.execute_requests[msg_id]["iopub"][0],
-                    deadline_to_timeout(deadline),
-                )
-            except asyncio.TimeoutError:
-                error_message = f"Kernel didn't respond in {timeout} seconds"
-                del self.execute_requests[msg_id]
-                raise RuntimeError(error_message)
-            await self._handle_outputs(
-                ydoc, ycell, self.execute_requests[msg_id]["iopub"]
-            )
-            try:
-                await asyncio.wait_for(
-                    self.execute_requests[msg_id]["shell"][0],
-                    deadline_to_timeout(deadline),
-                )
-            except asyncio.TimeoutError:
-                del self.execute_requests[msg_id]
-                error_message = f"Kernel didn't respond in {timeout} seconds"
-                raise RuntimeError(error_message)
-            msg = self.execute_requests[msg_id]["shell"][0].result()
-            with ydoc.begin_transaction() as txn:
-                ycell.set(txn, "execution_count", msg["content"]["execution_count"])
-            del self.execute_requests[msg_id]
-
-    async def _handle_outputs(
-        self, ydoc: Y.YDoc, ycell: Y.YMap, future_messages: List[asyncio.Future]
-    ):
-        with ydoc.begin_transaction() as txn:
-            ycell.set(txn, "outputs", [])
-
-        while True:
-            if not future_messages:
-                future_messages.append(asyncio.Future())
-            fut = future_messages[0]
-            if not fut.done():
-                await fut
-            future_messages.pop(0)
-            msg = fut.result()
-            msg_type = msg["header"]["msg_type"]
-            content = msg["content"]
-            outputs = list(ycell["outputs"])
-            if msg_type == "stream":
-                if (len(outputs) == 0) or (outputs[-1]["name"] != content["name"]):
-                    outputs.append(
-                        {"name": content["name"], "output_type": msg_type, "text": []}
-                    )
-                outputs[-1]["text"].append(content["text"])
-            elif msg_type in ("display_data", "execute_result"):
-                outputs.append(
-                    {
-                        "data": {"text/plain": [content["data"].get("text/plain", "")]},
-                        "execution_count": content["execution_count"],
-                        "metadata": {},
-                        "output_type": msg_type,
-                    }
-                )
-            elif msg_type == "error":
-                outputs.append(
-                    {
-                        "ename": content["ename"],
-                        "evalue": content["evalue"],
-                        "output_type": "error",
-                        "traceback": content["traceback"],
-                    }
-                )
-            elif msg_type == "status" and msg["content"]["execution_state"] == "idle":
-                break
-
-            with ydoc.begin_transaction() as txn:
-                ycell.set(txn, "outputs", outputs)

txl_remote_kernels-0.1.5/txl_remote_kernels/message.py

@@ -1,108 +0,0 @@
-import asyncio
-import json
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
-from uuid import uuid4
-
-from dateutil.parser import parse as dateutil_parse
-
-protocol_version_info = (5, 3)
-protocol_version = "%i.%i" % protocol_version_info
-
-
-def str_to_date(obj: Dict[str, Any]) -> Dict[str, Any]:
-    if "date" in obj:
-        obj["date"] = dateutil_parse(obj["date"])
-    return obj
-
-
-def date_to_str(obj: Dict[str, Any]):
-    if "date" in obj and type(obj["date"]) is not str:
-        obj["date"] = obj["date"].isoformat().replace("+00:00", "Z")
-    return obj
-
-
-def utcnow() -> datetime:
-    return datetime.utcnow().replace(tzinfo=timezone.utc)
-
-
-def create_message_header(
-    msg_type: str, session_id: str, msg_id: str
-) -> Dict[str, Any]:
-    if not session_id:
-        session_id = msg_id = uuid4().hex
-    else:
-        msg_id = f"{session_id}_{msg_id}"
-    header = {
-        "date": utcnow().isoformat().replace("+00:00", "Z"),
-        "msg_id": msg_id,
-        "msg_type": msg_type,
-        "session": session_id,
-        "username": "",
-        "version": protocol_version,
-    }
-    return header
-
-
-def create_message(
-    msg_type: str,
-    content: Dict = {},
-    session_id: str = "",
-    msg_id: str = "",
-) -> Dict[str, Any]:
-    header = create_message_header(msg_type, session_id, msg_id)
-    msg = {
-        "header": header,
-        "msg_id": header["msg_id"],
-        "msg_type": header["msg_type"],
-        "parent_header": {},
-        "content": content,
-        "metadata": {},
-        "buffers": [],
-    }
-    return msg
-
-
-def serialize(msg: Dict[str, Any]) -> List[bytes]:
-    # TODO: buffers
-    nbufs = int(1).to_bytes(4, "big")
-    offset_0 = int(8).to_bytes(4, "big")
-    message = nbufs + offset_0 + json.dumps(msg).encode("utf8")
-    return message
-
-
-def deserialize(
-    msg: bytes,
-) -> Dict[str, Any]:
-    # TODO: buffers
-    # nbufs = int.from_bytes(msg[:4], byteorder="little")
-    offset_0 = int.from_bytes(msg[4:8], byteorder="little")
-    message = json.loads(msg[offset_0:])
-    return message
-
-
-async def send_message(
-    message, channel: str, websocket, change_date_to_str: bool = False
-):
-    _date_to_str = date_to_str if change_date_to_str else lambda x: x
-    message["header"] = _date_to_str(message["header"])
-    message["parent_header"] = _date_to_str(message["parent_header"])
-    message["metadata"] = _date_to_str(message["metadata"])
-    message["content"] = _date_to_str(message.get("content", {}))
-    message["channel"] = channel
-    # msg = serialize(message)
-    # await websocket.send_bytes(msg)
-    await websocket.send_json(message)
-
-
-async def receive_message(
-    websocket, timeout: float, change_str_to_date: bool = False
-) -> Optional[Dict[str, Any]]:
-    try:
-        message = await websocket.receive_json(timeout)
-    except asyncio.TimeoutError:
-        return None
-    _str_to_date = str_to_date if change_str_to_date else lambda x: x
-    message["header"] = _str_to_date(message["header"])
-    message["parent_header"] = _str_to_date(message["parent_header"])
-    # return deserialize(message, change_str_to_date)