jupyter-server-ydoc 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

jupyter_server_ydoc/_version.py

@@ -1 +1 @@
-__version__ = "2.0.1"
+__version__ = "2.1.0"

jupyter_server_ydoc/app.py

@@ -105,7 +105,7 @@ class YDocExtension(ExtensionApp):
         page_config.setdefault("serverSideExecution", self.server_side_execution)
 
         # Set configurable parameters to YStore class
-        ystore_class = partial(self.ystore_class, config=self.config)
+        ystore_class: type[BaseYStore] = partial(self.ystore_class, config=self.config)  # type:ignore[assignment]
 
         self.ywebsocket_server = JupyterWebsocketServer(
             rooms_ready=False,
@@ -205,7 +205,7 @@ class YDocExtension(ExtensionApp):
             if copy:
                 update = room.ydoc.get_update()
 
-                fork_ydoc = Doc()
+                fork_ydoc: Doc = Doc()
                 fork_ydoc.apply_update(update)
 
                 return YDOCS.get(room.file_type, YDOCS["file"])(fork_ydoc)

jupyter_server_ydoc/handlers.py

@@ -5,18 +5,18 @@ from __future__ import annotations
 
 import asyncio
 import json
-import time
 import uuid
 from logging import Logger
-from typing import Any, Literal
+from typing import Any
 from uuid import uuid4
+from typing import cast
 
 from jupyter_server.auth import authorized
 from jupyter_server.base.handlers import APIHandler, JupyterHandler
 from jupyter_server.utils import ensure_async
 from jupyter_ydoc import ydocs as YDOCS
-from pycrdt import Doc, UndoManager, write_var_uint
-from pycrdt_websocket.websocket_server import YRoom
+from pycrdt import Doc, Encoder, UndoManager
+from pycrdt_websocket.yroom import YRoom
 from pycrdt_websocket.ystore import BaseYStore
 from tornado import web
 from tornado.websocket import WebSocketHandler
@@ -28,12 +28,13 @@ from .utils import (
     JUPYTER_COLLABORATION_EVENTS_URI,
     JUPYTER_COLLABORATION_FORK_EVENTS_URI,
     LogLevel,
-    MessageType,
     decode_file_path,
     encode_file_path,
     room_id_from_encoded_path,
 )
 from .websocketserver import JupyterWebsocketServer, RoomNotFound
+from .utils import MessageType
+from pycrdt import Decoder
 
 YFILE = YDOCS["file"]
 
@@ -117,7 +118,10 @@ class YDocWebSocketHandler(WebSocketHandler, JupyterHandler):
 
                     file = self._file_loaders[file_id]
                     updates_file_path = f".{file_type}:{file_id}.y"
-                    ystore = self._ystore_class(path=updates_file_path, log=self.log)
+                    ystore = self._ystore_class(
+                        path=updates_file_path,
+                        log=self.log,  # type:ignore[call-arg]
+                    )
                     self.room = DocumentRoom(
                         self._room_id,
                         file_format,
@@ -182,7 +186,7 @@ class YDocWebSocketHandler(WebSocketHandler, JupyterHandler):
         self._websocket_server = ywebsocket_server
         self._message_queue = asyncio.Queue()
         self._room_id = ""
-        self.room = None
+        self.room = None  # type:ignore
 
     @property
     def path(self):
@@ -219,7 +223,7 @@ class YDocWebSocketHandler(WebSocketHandler, JupyterHandler):
             raise web.HTTPError(403)
         return await super().get(*args, **kwargs)
 
-    async def open(self, room_id):
+    async def open(self, room_id: str) -> None:  # type:ignore[override]
         """
         On connection open.
         """
@@ -259,7 +263,7 @@ class YDocWebSocketHandler(WebSocketHandler, JupyterHandler):
                     )
 
                 # Clean up the room and delete the file loader
-                if len(self.room.clients) == 0 or self.room.clients == [self]:
+                if len(self.room.clients) == 0 or self.room.clients == {self}:
                     self._message_queue.put_nowait(b"")
                     self._cleanup_delay = 0
                     await self._clean_room()
@@ -269,7 +273,7 @@ class YDocWebSocketHandler(WebSocketHandler, JupyterHandler):
             if self._room_id != "JupyterLab:globalAwareness":
                 self._emit_awareness_event(self.current_user.username, "join")
 
-    async def send(self, message):
+    async def send(self, message: bytes) -> None:
         """
         Send a message to the client.
         """
@@ -290,38 +294,50 @@ class YDocWebSocketHandler(WebSocketHandler, JupyterHandler):
         """
         On message receive.
         """
-        message_type = message[0]
-
-        if message_type == MessageType.CHAT:
-            msg = message[2:].decode("utf-8")
-
-            user = self.current_user
-            data = json.dumps(
-                {
-                    "sender": user.username,
-                    "timestamp": time.time(),
-                    "content": json.loads(msg),
+        decoder = Decoder(message)
+        header = decoder.read_var_uint()
+        if header == MessageType.RAW:
+            msg = decoder.read_var_string()
+            if msg == "save":
+                save_id = decoder.read_var_uint()
+                save_reply = {
+                    "type": "save",
+                    "responseTo": save_id,
                 }
-            ).encode("utf8")
-
-            for client in self.room.clients:
-                if client != self:
-                    task = asyncio.create_task(
-                        client.send(bytes([MessageType.CHAT]) + write_var_uint(len(data)) + data)
-                    )
-                    self._websocket_server.background_tasks.add(task)
-                    task.add_done_callback(self._websocket_server.background_tasks.discard)
+                try:
+                    room = cast(DocumentRoom, self.room)
+                    save_task = room._save_to_disc()
+                    # task may be missing if save was already in progress
+                    if save_task:
+                        await save_task
+                        await self.send(
+                            self._encode_json_message({**save_reply, "status": "success"})
+                        )
+                    else:
+                        await self.send(
+                            self._encode_json_message({**save_reply, "status": "skipped"})
+                        )
+                except Exception:
+                    self.log.error("Couldn't save content from room: %s", self._room_id)
+                    await self.send(self._encode_json_message({**save_reply, "status": "failed"}))
+            return
 
         self._message_queue.put_nowait(message)
         self._websocket_server.ypatch_nb += 1
 
+    def _encode_json_message(self, message: dict) -> bytes:
+        encoder = Encoder()
+        encoder.write_var_uint(MessageType.RAW)
+        encoder.write_var_string(json.dumps(message))
+        return encoder.to_bytes()
+
     def on_close(self) -> None:
         """
         On connection close.
         """
         # stop serving this client
         self._message_queue.put_nowait(b"")
-        if isinstance(self.room, DocumentRoom) and self.room.clients == [self]:
+        if isinstance(self.room, DocumentRoom) and self.room.clients == {self}:
             # no client in this room after we disconnect
             # keep the document for a while in case someone reconnects
             self.log.info("Cleaning room: %s", self._room_id)
@@ -386,9 +402,7 @@ class YDocWebSocketHandler(WebSocketHandler, JupyterHandler):
                 self._emit(LogLevel.INFO, "clean", "Loader deleted.")
             del self._room_locks[self._room_id]
 
-    def _on_global_awareness_event(
-        self, topic: Literal["change", "update"], changes: tuple[dict[str, Any], Any]
-    ) -> None:
+    def _on_global_awareness_event(self, topic: str, changes: tuple[dict[str, Any], Any]) -> None:
         """
         Update the users when the global awareness changes.
 
@@ -489,7 +503,7 @@ class TimelineHandler(APIHandler):
         try:
             room_id = room_id_from_encoded_path(encoded_path)
             room: YRoom = await self.ywebsocket_server.get_room(room_id)
-            fork_ydoc = Doc()
+            fork_ydoc: Doc = Doc()
 
             ydoc_factory = YDOCS.get(content_type)
             if ydoc_factory is None:
@@ -505,7 +519,9 @@ class TimelineHandler(APIHandler):
             FORK_DOCUMENTS[idx] = ydoc_factory(fork_ydoc)
             undo_manager: UndoManager = FORK_DOCUMENTS[idx].undo_manager
 
-            updates_and_timestamps = [(item[0], item[-1]) async for item in room.ystore.read()]
+            ystore = room.ystore
+            assert ystore
+            updates_and_timestamps = [(item[0], item[-1]) async for item in ystore.read()]
 
             result_timestamps = []
 
@@ -649,7 +665,7 @@ class DocForkHandler(APIHandler):
             return self.finish({"code": 404, "error": "Root room not found"})
 
         update = root_room.ydoc.get_update()
-        fork_ydoc = Doc()
+        fork_ydoc: Doc = Doc()
         fork_ydoc.apply_update(update)
         model = self.get_json_body()
         synchronize = model.get("synchronize", False)

jupyter_server_ydoc/loaders.py

@@ -203,13 +203,28 @@ class FileLoader:
         if self._poll_interval is None:
             return
 
+        consecutive_error_logs = 0
+        max_consecutive_logs = 3
+        suppression_logged = False
+
         while True:
             try:
                 await asyncio.sleep(self._poll_interval)
                 try:
                     await self.maybe_notify()
+                    consecutive_error_logs = 0
+                    suppression_logged = False
                 except Exception as e:
-                    self._log.error(f"Error watching file: {self.path}\n{e!r}", exc_info=e)
+                    if consecutive_error_logs < max_consecutive_logs:
+                        self._log.error(f"Error watching file: {self.path}\n{e!r}", exc_info=e)
+                        consecutive_error_logs += 1
+                    elif not suppression_logged:
+                        self._log.warning(
+                            "Too many errors while watching %s — suppressing further logs.",
+                            self.path,
+                        )
+                        suppression_logged = True
+
             except asyncio.CancelledError:
                 break
 

jupyter_server_ydoc/pytest_plugin.py

@@ -240,7 +240,12 @@ def rtc_add_doc_to_store(rtc_connect_doc_client):
 
 def rtc_create_SQLite_store_factory(jp_serverapp):
     async def _inner(type: str, path: str, content: str) -> DocumentRoom:
-        db = SQLiteYStore(path=f"{type}:{path}", config=jp_serverapp.config)
+        db = SQLiteYStore(
+            path=f"{type}:{path}",
+            # `SQLiteYStore` here is a subclass of booth `LoggingConfigurable`
+            # and `pycrdt_websocket.ystore.SQLiteYStore`, but mypy gets lost:
+            config=jp_serverapp.config,  # type:ignore[call-arg]
+        )
         _ = create_task(db.start())
         await db.started.wait()
 
@@ -271,7 +276,7 @@ def rtc_create_mock_document_room():
         last_modified: datetime | None = None,
         save_delay: float | None = None,
         store: SQLiteYStore | None = None,
-        writable: bool = False,
+        writable: bool = True,
     ) -> tuple[FakeContentsManager, FileLoader, DocumentRoom]:
         paths = {id: path}
 

jupyter_server_ydoc/rooms.py

@@ -9,7 +9,7 @@ from typing import Any, Callable
 
 from jupyter_events import EventLogger
 from jupyter_ydoc import ydocs as YDOCS
-from pycrdt_websocket.websocket_server import YRoom
+from pycrdt_websocket.yroom import YRoom
 from pycrdt_websocket.ystore import BaseYStore, YDocNotFound
 
 from .loaders import FileLoader
@@ -103,7 +103,7 @@ class DocumentRoom(YRoom):
             It is important to set the ready property in the parent class (`self.ready = True`),
             this setter will subscribe for updates on the shared document.
         """
-        if self.ready:  # type: ignore[has-type]
+        if self.ready:
             return
 
         self.log.info("Initializing room %s", self._room_id)
@@ -247,12 +247,40 @@ class DocumentRoom(YRoom):
             document. This tasks are debounced (60 seconds by default) so we
             need to cancel previous tasks before creating a new one.
         """
+        # Collect autosave values from all clients
+        autosave_states = [
+            state.get("autosave", True)
+            for state in self.awareness.states.values()
+            if state  # skip empty states
+        ]
+
+        # If no states exist (e.g., during tests), force autosave to be True
+        if not autosave_states:
+            autosave_states = [True]
+
+        # Enable autosave if at least one client has it turned on
+        autosave = any(autosave_states)
+
+        if not autosave:
+            return
+        if self._update_lock.locked():
+            return
+
+        self._saving_document = asyncio.create_task(
+            self._maybe_save_document(self._saving_document)
+        )
+
+    def _save_to_disc(self):
+        """
+        Called when manual save is triggered. Helpful when autosave is turned off.
+        """
         if self._update_lock.locked():
             return
 
         self._saving_document = asyncio.create_task(
             self._maybe_save_document(self._saving_document)
         )
+        return self._saving_document
 
     async def _maybe_save_document(self, saving_document: asyncio.Task | None) -> None:
         """
@@ -265,7 +293,6 @@ class DocumentRoom(YRoom):
         """
         if self._save_delay is None:
             return
-
         if saving_document is not None and not saving_document.done():
             # the document is being saved, cancel that
             saving_document.cancel()
@@ -285,9 +312,9 @@ class DocumentRoom(YRoom):
                     "content": self._document.source,
                 }
             )
-            async with self._update_lock:
-                self._document.dirty = False
-                if saved_model:
+            if saved_model:
+                async with self._update_lock:
+                    self._document.dirty = False
                     self._document.hash = saved_model["hash"]
 
             self._emit(LogLevel.INFO, "save", "Content saved.")

jupyter_server_ydoc/utils.py

@@ -19,6 +19,7 @@ FORK_EVENTS_SCHEMA_PATH = EVENTS_FOLDER_PATH / "fork.yaml"
 class MessageType(IntEnum):
     SYNC = 0
     AWARENESS = 1
+    RAW = 2
     CHAT = 125
 
 

jupyter_server_ydoc/websocketserver.py

@@ -7,9 +7,10 @@ import asyncio
 from logging import Logger
 from typing import Any, Callable
 
-from pycrdt_websocket.websocket_server import WebsocketServer, YRoom
+from pycrdt_websocket.websocket import Websocket
+from pycrdt_websocket.websocket_server import WebsocketServer
+from pycrdt_websocket.yroom import YRoom
 from pycrdt_websocket.ystore import BaseYStore
-from tornado.websocket import WebSocketHandler
 
 
 class RoomNotFound(LookupError):
@@ -38,7 +39,7 @@ class JupyterWebsocketServer(WebsocketServer):
 
     def __init__(
         self,
-        ystore_class: BaseYStore,
+        ystore_class: type[BaseYStore],
         rooms_ready: bool = True,
         auto_clean_rooms: bool = True,
         exception_handler: Callable[[Exception, Logger], bool] | None = None,
@@ -132,7 +133,7 @@ class JupyterWebsocketServer(WebsocketServer):
         await self.start_room(room)
         return room
 
-    async def serve(self, websocket: WebSocketHandler) -> None:
+    async def serve(self, websocket: Websocket) -> None:
         # start monitoring here as the event loop is not yet available when initializing the object
         if self.monitor_task is None:
             self.monitor_task = asyncio.create_task(self._monitor())

{jupyter_server_ydoc-2.0.1.dist-info → jupyter_server_ydoc-2.1.0.dist-info}/METADATA

@@ -1,7 +1,12 @@
 Metadata-Version: 2.4
 Name: jupyter-server-ydoc
-Version: 2.0.1
+Version: 2.1.0
 Summary: jupyter-server extension integrating collaborative shared models.
+Project-URL: Documentation, https://jupyterlab-realtime-collaboration.readthedocs.io/
+Project-URL: Repository, https://github.com/jupyterlab/jupyter-collaboration
+Project-URL: Changelog, https://jupyterlab-realtime-collaboration.readthedocs.io/en/latest/changelog.html
+Project-URL: Source, https://github.com/jupyterlab/jupyter-collaboration/tree/main/projects/jupyter-server-ydoc
+Project-URL: Issues, https://github.com/jupyterlab/jupyter-collaboration/issues/new/choose
 Author-email: Jupyter Development Team <jupyter@googlegroups.com>
 License: # Licensing terms
         

jupyter_server_ydoc-2.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+jupyter_server_ydoc/__init__.py,sha256=B8H7XLhzgrTCQD8304Lx91FYXslwabsnV9OuYu4M4Hw,346
+jupyter_server_ydoc/_version.py,sha256=Xybt2skBZamGMNlLuOX1IG-h4uIxqUDGAO8MIGWrJac,22
+jupyter_server_ydoc/app.py,sha256=6Zca0acaEFCKyUbXdmcPmVk1Dgu91Y-DFjYR16WKFlg,8161
+jupyter_server_ydoc/handlers.py,sha256=x3R5VluXWFN460AiC7xNbipSpCR7SQSjqrcwjBorgpw,28836
+jupyter_server_ydoc/loaders.py,sha256=XUQqg2EbfQUYlQVjHY183gYKeVZ6x92VHy4EsOQz4fA,11303
+jupyter_server_ydoc/pytest_plugin.py,sha256=yMVlk7fvHXiM7g6ua0Ophc96cFwC0bmTWVDbbUeu2DE,8741
+jupyter_server_ydoc/rooms.py,sha256=O0dYKeDRMUPFRraFJf8irqnFaSD80hirrtAYBXKTgrM,13103
+jupyter_server_ydoc/stores.py,sha256=_5J6eNs3R5Tv88PCc-GGuszxQstfvNoBCYABqzBzJXA,1004
+jupyter_server_ydoc/test_utils.py,sha256=utUwB5FThc_SCQshhUbLNih9GUa5qBcmMgU6-jx0ZnA,2275
+jupyter_server_ydoc/utils.py,sha256=_wI4CFOEZK4MSMYCZe2moSbggUTRdGxY4qTzSDEFzdE,2183
+jupyter_server_ydoc/websocketserver.py,sha256=h1yTgJcsCK17_97Ne5x-lbgIFsxylwnltxagcuAlTJY,5185
+jupyter_server_ydoc/events/awareness.yaml,sha256=2FrCci5rZIaU4rn8pIPZJkd132YAZdzKjSNSwjOY7Dk,755
+jupyter_server_ydoc/events/fork.yaml,sha256=3OrhQjhVyLjlBJWMiffbnZodL3GzFafLwEmSBFrK33o,1303
+jupyter_server_ydoc/events/session.yaml,sha256=PS0MxowpRwY5QFYm-LJvHUxKHnsictV8_6VEwfhYxcQ,1596
+jupyter_server_ydoc-2.1.0.data/data/etc/jupyter/jupyter_server_config.d/jupyter_collaboration.json,sha256=0thh2hJUxAKkZSmneJMG0U6QJRjdM6zGlwrTedEt-Jk,94
+jupyter_server_ydoc-2.1.0.dist-info/METADATA,sha256=Rfb1XEPiOQTYrI0JZ8ZFpiYvWIhmxCalR0-OmFPVwT8,5587
+jupyter_server_ydoc-2.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+jupyter_server_ydoc-2.1.0.dist-info/licenses/LICENSE,sha256=mhO0ZW9EiWOPg0dUgB-lNbJ0CGwRmTdbeAg_se1SOnY,2833
+jupyter_server_ydoc-2.1.0.dist-info/RECORD,,

jupyter_server_ydoc-2.0.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-jupyter_server_ydoc/__init__.py,sha256=B8H7XLhzgrTCQD8304Lx91FYXslwabsnV9OuYu4M4Hw,346
-jupyter_server_ydoc/_version.py,sha256=wAxkK8w13vqoF47A8iqWdSlIgRRXmZiQ0R4wePZfzhs,22
-jupyter_server_ydoc/app.py,sha256=JqkpijoPdo_qum0CKqbG-I6W8fpC3-v2cFA3kFxK3mg,8111
-jupyter_server_ydoc/handlers.py,sha256=Q0A638Ke_TR-hSdAgyz8u1gIOCk3FIqWRhV-QH2PLMM,27977
-jupyter_server_ydoc/loaders.py,sha256=rUPZZsMIxcE7ZEWTY8O2_ib7DUCmLvvdptqZYpsusdY,10676
-jupyter_server_ydoc/pytest_plugin.py,sha256=M9dQhiyDnGxFWxoGDj5l5lRVyfkYFKdU2i1Yj_Z16sU,8525
-jupyter_server_ydoc/rooms.py,sha256=szOAfMldhQIrmVpqoF75O0_KXY54X_TrzJz6vpjR6kE,12254
-jupyter_server_ydoc/stores.py,sha256=_5J6eNs3R5Tv88PCc-GGuszxQstfvNoBCYABqzBzJXA,1004
-jupyter_server_ydoc/test_utils.py,sha256=utUwB5FThc_SCQshhUbLNih9GUa5qBcmMgU6-jx0ZnA,2275
-jupyter_server_ydoc/utils.py,sha256=EgKC15js8VOS8-5jGMs4pfHQfV9drnNT2Gew5UlyXZc,2171
-jupyter_server_ydoc/websocketserver.py,sha256=7fLPJcWczD-4R_-LXtfvNxM_pUXFasZWDmT4RIrOQHE,5150
-jupyter_server_ydoc/events/awareness.yaml,sha256=2FrCci5rZIaU4rn8pIPZJkd132YAZdzKjSNSwjOY7Dk,755
-jupyter_server_ydoc/events/fork.yaml,sha256=3OrhQjhVyLjlBJWMiffbnZodL3GzFafLwEmSBFrK33o,1303
-jupyter_server_ydoc/events/session.yaml,sha256=PS0MxowpRwY5QFYm-LJvHUxKHnsictV8_6VEwfhYxcQ,1596
-jupyter_server_ydoc-2.0.1.data/data/etc/jupyter/jupyter_server_config.d/jupyter_collaboration.json,sha256=0thh2hJUxAKkZSmneJMG0U6QJRjdM6zGlwrTedEt-Jk,94
-jupyter_server_ydoc-2.0.1.dist-info/METADATA,sha256=-hxNueyhVsO-DXfdiYoiBpQ_rvk6MU9OwRnh-xHg3LA,5115
-jupyter_server_ydoc-2.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-jupyter_server_ydoc-2.0.1.dist-info/licenses/LICENSE,sha256=mhO0ZW9EiWOPg0dUgB-lNbJ0CGwRmTdbeAg_se1SOnY,2833
-jupyter_server_ydoc-2.0.1.dist-info/RECORD,,