jupyter-server-ydoc 2.2.0b0__tar.gz → 2.2.1__tar.gz

{jupyter_server_ydoc-2.2.0b0 → jupyter_server_ydoc-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jupyter-server-ydoc
-Version: 2.2.0b0
+Version: 2.2.1
 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

jupyter_server_ydoc-2.2.1/jupyter_server_ydoc/_version.py

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

{jupyter_server_ydoc-2.2.0b0 → jupyter_server_ydoc-2.2.1}/jupyter_server_ydoc/loaders.py

@@ -86,7 +86,7 @@ class FileLoader:
             try:
                 await self._watcher
             except asyncio.CancelledError:
-                self._log.info(f"file watcher for '{self.file_id}' is cancelled now")
+                self._log.info(f"File watcher for '{self.file_id}' was cancelled")
 
     def observe(
         self,

{jupyter_server_ydoc-2.2.0b0 → jupyter_server_ydoc-2.2.1}/jupyter_server_ydoc/pytest_plugin.py

@@ -30,7 +30,14 @@ def rtc_document_save_delay():
 
 
 @pytest.fixture
-def jp_server_config(jp_root_dir, jp_server_config, rtc_document_save_delay):
+def rtc_document_cleanup_delay():
+    return 60
+
+
+@pytest.fixture
+def jp_server_config(
+    jp_root_dir, jp_server_config, rtc_document_save_delay, rtc_document_cleanup_delay
+):
     return {
         "ServerApp": {
             "jpserver_extensions": {
@@ -47,7 +54,10 @@ def jp_server_config(jp_root_dir, jp_server_config, rtc_document_save_delay):
             "db_path": str(jp_root_dir.joinpath(".fid_test.db")),
             "db_journal_mode": "OFF",
         },
-        "YDocExtension": {"document_save_delay": rtc_document_save_delay},
+        "YDocExtension": {
+            "document_save_delay": rtc_document_save_delay,
+            "document_cleanup_delay": rtc_document_cleanup_delay,
+        },
     }
 
 

{jupyter_server_ydoc-2.2.0b0 → jupyter_server_ydoc-2.2.1}/jupyter_server_ydoc/rooms.py

@@ -278,20 +278,28 @@ class DocumentRoom(YRoom):
             return
 
         self._saving_document = asyncio.create_task(
-            self._maybe_save_document(self._saving_document)
+            self._maybe_save_document(self._saving_document, save_now=True)
         )
         return self._saving_document
 
-    async def _maybe_save_document(self, saving_document: asyncio.Task | None) -> None:
+    async def _maybe_save_document(
+        self, saving_document: asyncio.Task | None, save_now: bool = False
+    ) -> None:
         """
         Saves the content of the document to disk.
 
         ### Note:
             There is a save delay to debounce the save since we could receive a high
             amount of changes in a short period of time. This way we can cancel the
-            previous save.
+            previous save. When save_now is True, the delay is skipped and the save
+            executes immediately.
+
+            Parameters:
+                saving_document: The previous saving task to cancel if needed.
+                save_now: If True, skip the debounce delay, and save immediately.
+                          This is used when manually saving.
         """
-        if self._save_delay is None:
+        if self._save_delay is None and not save_now:
             return
         if saving_document is not None and not saving_document.done():
             # the document is being saved, cancel that
@@ -301,8 +309,10 @@ class DocumentRoom(YRoom):
         # because this coroutine is run in a cancellable task and cancellation is handled here
 
         try:
-            # save after X seconds of inactivity
-            await asyncio.sleep(self._save_delay)
+            # When save_now is False, wait X seconds of inactivity before saving (auto-save).
+            # When save_now is True, save immediately without debounce delay (manual save).
+            if not save_now and self._save_delay is not None:
+                await asyncio.sleep(self._save_delay)
 
             self.log.info("Saving the content from room %s", self._room_id)
             saved_model = await self._file.maybe_save_content(

{jupyter_server_ydoc-2.2.0b0 → jupyter_server_ydoc-2.2.1}/jupyter_server_ydoc/stores.py

@@ -27,10 +27,17 @@ class SQLiteYStore(LoggingConfigurable, _SQLiteYStore, metaclass=SQLiteYStoreMet
         directory.""",
     )
 
-    document_ttl = Int(
+    squash_after_inactivity_of = Int(
         None,
         allow_none=True,
         config=True,
         help="""The document time-to-live in seconds. Defaults to None (document history is never
         cleared).""",
     )
+    document_ttl = Int(
+        None,
+        allow_none=True,
+        config=True,
+        help="""The document time-to-live in seconds. Deprecated in favor of 'squash_after_inactivity_of'.
+        Defaults to None (document history is never cleared).""",
+    )

{jupyter_server_ydoc-2.2.0b0 → jupyter_server_ydoc-2.2.1}/jupyter_server_ydoc/test_utils.py

@@ -33,13 +33,19 @@ class FakeContentsManager:
             "mimetype": None,
             "size": 0,
             "writable": False,
+            "hash": "fake_hash",
         }
         self.model.update(model)
 
         self.actions: list[str] = []
 
     def get(
-        self, path: str, content: bool = True, format: str | None = None, type: str | None = None
+        self,
+        path: str,
+        content: bool = True,
+        format: str | None = None,
+        type: str | None = None,
+        require_hash: bool | None = None,
     ) -> dict:
         if not self.model:
             raise HTTPError(404, f"File not found: {path}")

{jupyter_server_ydoc-2.2.0b0 → jupyter_server_ydoc-2.2.1}/tests/test_app.py

@@ -74,7 +74,23 @@ async def test_document_ttl_from_settings(rtc_create_mock_document_room, jp_conf
     rtc_create_SQLite_store = rtc_create_SQLite_store_factory(app)
     store = await rtc_create_SQLite_store("file", id, content)
 
-    assert store.document_ttl == 3600
+    # document_ttl is deprecated and mapped to squash_after_inactivity_of
+    assert store.squash_after_inactivity_of == 3600
+
+
+async def test_squash_after_inactivity_of_from_settings(
+    rtc_create_mock_document_room, jp_configurable_serverapp
+):
+    argv = ["--SQLiteYStore.squash_after_inactivity_of=3600"]
+
+    app = jp_configurable_serverapp(argv=argv)
+
+    id = "test-id"
+    content = "test_ttl"
+    rtc_create_SQLite_store = rtc_create_SQLite_store_factory(app)
+    store = await rtc_create_SQLite_store("file", id, content)
+
+    assert store.squash_after_inactivity_of == 3600
 
 
 @pytest.mark.parametrize("copy", [True, False])

{jupyter_server_ydoc-2.2.0b0 → jupyter_server_ydoc-2.2.1}/tests/test_documents.py

@@ -69,7 +69,8 @@ async def test_room_concurrent_initialization(
         tg.start_soon(connect, file_format, file_type, file_path)
         tg.start_soon(connect, file_format, file_type, file_path)
     t1 = time()
-    assert t1 - t0 < 0.5
+    delta = t1 - t0
+    assert delta < 0.6
 
     await cleanup(jp_serverapp)
 

{jupyter_server_ydoc-2.2.0b0 → jupyter_server_ydoc-2.2.1}/tests/test_handlers.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import json
+import pytest
 from asyncio import Event, sleep
 from typing import Any
 
@@ -133,6 +134,71 @@ async def test_room_handler_doc_client_should_emit_awareness_event(
     assert collected_data[1]["username"] is not None
 
 
+@pytest.fixture
+def rtc_document_cleanup_delay():
+    return 2
+
+
+async def test_room_handler_doc_client_should_stop_file_watcher(
+    rtc_create_file, rtc_connect_doc_client, jp_serverapp
+):
+    path, _ = await rtc_create_file("test.txt", "test")
+    fim = jp_serverapp.web_app.settings["file_id_manager"]
+    file_loaders = jp_serverapp.web_app.settings["jupyter_server_ydoc"].file_loaders
+
+    event = Event()
+
+    def _on_document_change(target: str, e: Any) -> None:
+        if target == "source":
+            event.set()
+
+    doc = YUnicode()
+    doc.observe(_on_document_change)
+
+    websocket, room_name = await rtc_connect_doc_client("text", "file", path)
+    async with websocket as ws, Provider(doc.ydoc, HttpxWebsocket(ws, room_name)):
+        await event.wait()
+        file_id = fim.get_id("test.txt")
+        assert file_id in file_loaders
+        file_loader = file_loaders[file_id]
+        await sleep(0.1)
+
+    listener_was_called = False
+    collected_data = []
+
+    async def my_listener(logger: EventLogger, schema_id: str, data: dict) -> None:
+        nonlocal listener_was_called
+        collected_data.append(data)
+        listener_was_called = True
+
+    event_logger = jp_serverapp.event_logger
+    event_logger.add_listener(
+        schema_id="https://schema.jupyter.org/jupyter_collaboration/session/v1",
+        listener=my_listener,
+    )
+
+    file_watcher = file_loader._watcher
+
+    # Before cleanup delay, the file watcher should still be running
+    assert not file_watcher.done()
+
+    # Wait for the cleanup delay (2 seconds) plus a buffer (0.5 seconds)
+    await sleep(2.5)
+
+    assert listener_was_called is True
+    assert len(collected_data) == 2
+    assert collected_data[0]["msg"] == "Room deleted."
+    assert collected_data[0]["path"] == "test.txt"
+    assert collected_data[1]["msg"] == "Loader deleted."
+    assert collected_data[1]["path"] == "test.txt"
+
+    # After the cleanup delay, the file watcher should be done
+    assert file_watcher.done()
+
+    await jp_serverapp.web_app.settings["jupyter_server_ydoc"].stop_extension()
+    del jp_serverapp.web_app.settings["file_id_manager"]
+
+
 async def test_room_handler_doc_client_should_cleanup_room_file(
     rtc_create_file, rtc_connect_doc_client, jp_serverapp
 ):

{jupyter_server_ydoc-2.2.0b0 → jupyter_server_ydoc-2.2.1}/tests/test_loaders.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 from datetime import datetime, timedelta, timezone
 
 from jupyter_server_ydoc.loaders import FileLoader, FileLoaderMapping
@@ -82,6 +83,27 @@ async def test_FileLoader_with_watcher_errors(caplog):
         await loader.clean()
 
 
+async def test_FileLoader_clean_logs_cancellation(caplog):
+    id = "file-4567"
+    path = "myfile.txt"
+    paths = {id: path}
+
+    cm = FakeContentsManager({"last_modified": datetime.now(timezone.utc)})
+    loader = FileLoader(
+        id,
+        FakeFileIDManager(paths),
+        cm,
+        poll_interval=0.05,
+    )
+    await loader.load_content("text", "file")
+
+    caplog.set_level(logging.INFO)
+    await loader.clean()
+
+    messages = [r.getMessage() for r in caplog.records]
+    assert f"File watcher for '{id}' was cancelled" in messages
+
+
 async def test_FileLoader_without_watcher():
     id = "file-4567"
     path = "myfile.txt"

{jupyter_server_ydoc-2.2.0b0 → jupyter_server_ydoc-2.2.1}/tests/test_rooms.py

@@ -121,6 +121,109 @@ async def test_should_save_content_when_at_least_one_client_has_autosave_enabled
     assert "save" in cm.actions
 
 
+async def test_manual_save_should_not_have_delay(
+    rtc_create_mock_document_room,
+):
+    content = "test"
+    cm, _, room = rtc_create_mock_document_room("test-id", "test.txt", content, save_delay=0.5)
+
+    await room.initialize()
+
+    # Trigger a manual save
+    room._save_to_disc()
+
+    # Manual save should execute immediately, without waiting for the 0.5s delay
+    # Check that save happens within a very short time (100ms should be enough)
+    await asyncio.sleep(0.1)
+
+    assert cm.actions.count("save") == 1
+
+
+async def test_manual_save_with_pending_autosave_should_cancel_autosave(
+    rtc_create_mock_document_room,
+):
+    content = "test"
+    cm, _, room = rtc_create_mock_document_room("test-id", "test.txt", content, save_delay=1.0)
+
+    await room.initialize()
+
+    room._document.source = "Test 2"
+
+    await asyncio.sleep(0.1)
+
+    assert cm.actions.count("save") == 0
+
+    save_task = room._save_to_disc()
+
+    # Manual save should execute immediately
+    await asyncio.sleep(0.1)
+    assert save_task.done()
+
+    # Check that the manual save was recorded
+    assert cm.actions.count("save") == 1
+
+    await asyncio.sleep(1.0)
+
+    # There should be only one save (the manual one), not two
+    assert cm.actions.count("save") == 1
+
+
+async def test_manual_save_should_execute_immediately_even_with_long_delay(
+    rtc_create_mock_document_room,
+):
+    content = "test"
+    cm, _, room = rtc_create_mock_document_room("test-id", "test.txt", content, save_delay=5.0)
+
+    await room.initialize()
+
+    save_task = room._save_to_disc()
+
+    await asyncio.sleep(0.5)
+
+    assert "save" in cm.actions
+    assert save_task.done()
+
+
+async def test_autosave_should_still_have_delay(
+    rtc_create_mock_document_room,
+):
+    content = "test"
+    save_delay = 0.3
+    cm, _, room = rtc_create_mock_document_room(
+        "test-id", "test.txt", content, save_delay=save_delay
+    )
+
+    await room.initialize()
+
+    room._document.source = "Test 3"
+
+    await asyncio.sleep(0.1)
+    assert "save" not in cm.actions
+
+    # Wait for the delay to complete
+    await asyncio.sleep(save_delay)
+
+    assert "save" in cm.actions
+
+
+async def test_manual_save_should_work_when_save_delay_is_none_and_save_now_is_true(
+    rtc_create_mock_document_room,
+):
+    """Test that manual saves execute even when save_delay is None."""
+    content = "test"
+    # When save_delay is None, autosave is disabled
+    cm, _, room = rtc_create_mock_document_room("test-id", "test.txt", content, save_delay=None)
+
+    await room.initialize()
+
+    # Trigger a manual save with save_now=True
+    # Even though save_delay is None, manual saves should still work
+    await room._maybe_save_document(None, save_now=True)
+
+    # Manual save should have executed
+    assert cm.actions.count("save") == 1
+
+
 # The following test should be restored when package versions are fixed.
 
 # async def test_document_path(rtc_create_mock_document_room):

jupyter_server_ydoc-2.2.0b0/jupyter_server_ydoc/_version.py

@@ -1 +0,0 @@
-__version__ = "2.2.0b0"