Update yrs v0.18.0 (#83)

* Update yrs v0.18.0

* Add Subscription class

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Fix typing

* Fix linting, replace black with ruff-format

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: davidbrochart

.pre-commit-config.yaml

@@ -1,11 +1,7 @@
 repos:
-  - repo: https://github.com/psf/black
-    rev: 24.2.0
-    hooks:
-      - id: black
-
   - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: v0.3.2
     hooks:
       - id: ruff
-        args: ["--fix"]
+        args: [--fix, --show-fixes]
+      - id: ruff-format

Cargo.toml

@@ -8,7 +8,7 @@ name = "pycrdt"
 crate-type = ["cdylib"]
 
 [dependencies]
-yrs = "0.17.4"
+yrs = "0.18.0"
 
 [dependencies.pyo3]
 version = "0.20.2"

README.md

@@ -1,6 +1,5 @@
 [![Build Status](https://github.com/jupyter-server/pycrdt/actions/workflows/test.yml/badge.svg?query=branch%3Amain++)](https://github.com/jupyter-server/pycrdt/actions/workflows/test.yml/badge.svg?query=branch%3Amain++)
 [![Code Coverage](https://img.shields.io/badge/coverage-100%25-green)](https://img.shields.io/badge/coverage-100%25-green)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 # pycrdt
 

pyproject.toml

@@ -49,7 +49,7 @@ module-name = "pycrdt._pycrdt"
 
 [tool.ruff]
 line-length = 100
-select = ["F", "E", "W", "I001"]
+lint.select = ["F", "E", "W", "I001"]
 
 [tool.coverage.run]
 source = ["python", "tests"]

python/pycrdt/_array.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-from functools import partial
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from ._base import BaseDoc, BaseEvent, BaseType, base_types, event_types
 from ._pycrdt import Array as _Array
@@ -183,34 +182,6 @@ def to_py(self) -> list | None:
                 py[idx] = val.to_py()
         return py
 
-    def observe(self, callback: Callable[[Any], None]) -> str:
-        _callback = partial(observe_callback, callback, self.doc)
-        return f"o_{self.integrated.observe(_callback)}"
-
-    def observe_deep(self, callback: Callable[[Any], None]) -> str:
-        _callback = partial(observe_deep_callback, callback, self.doc)
-        return f"od{self.integrated.observe_deep(_callback)}"
-
-    def unobserve(self, subscription_id: str) -> None:
-        sid = int(subscription_id[2:])
-        if subscription_id.startswith("o_"):
-            self.integrated.unobserve(sid)
-        else:
-            self.integrated.unobserve_deep(sid)
-
-
-def observe_callback(callback: Callable[[Any], None], doc: Doc, event: Any):
-    _event = event_types[type(event)](event, doc)
-    with doc._read_transaction(event.transaction):
-        callback(_event)
-
-
-def observe_deep_callback(callback: Callable[[Any], None], doc: Doc, events: list[Any]):
-    for idx, event in enumerate(events):
-        events[idx] = event_types[type(event)](event, doc)
-    with doc._read_transaction(event.transaction):
-        callback(events)
-
 
 class ArrayEvent(BaseEvent):
     __slots__ = "target", "delta", "path"

python/pycrdt/_base.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Type, cast
+from functools import partial
+from typing import TYPE_CHECKING, Any, Callable, Type, cast
 
 from ._pycrdt import Doc as _Doc
+from ._pycrdt import Subscription
 from ._pycrdt import Transaction as _Transaction
 from ._transaction import ReadTransaction, Transaction
 
@@ -73,9 +75,7 @@ def _init(self, value: Any | None) -> None: ...
 
     def _forbid_read_transaction(self, txn: Transaction):
         if isinstance(txn, ReadTransaction):
-            raise RuntimeError(
-                "Read-only transaction cannot be used to modify document structure"
-            )
+            raise RuntimeError("Read-only transaction cannot be used to modify document structure")
 
     def _integrate(self, doc: Doc, integrated: Any) -> Any:
         prelim = self._prelim
@@ -84,9 +84,7 @@ def _integrate(self, doc: Doc, integrated: Any) -> Any:
         self._integrated = integrated
         return prelim
 
-    def _do_and_integrate(
-        self, action: str, value: BaseType, txn: _Transaction, *args
-    ) -> None:
+    def _do_and_integrate(self, action: str, value: BaseType, txn: _Transaction, *args) -> None:
         method = getattr(self._integrated, f"{action}_{value.type_name}_prelim")
         integrated = method(txn, *args)
         assert self._doc is not None
@@ -132,6 +130,30 @@ def prelim(self) -> Any:
     def type_name(self) -> str:
         return self._type_name
 
+    def observe(self, callback: Callable[[Any], None]) -> Subscription:
+        _callback = partial(observe_callback, callback, self.doc)
+        return self.integrated.observe(_callback)
+
+    def observe_deep(self, callback: Callable[[Any], None]) -> Subscription:
+        _callback = partial(observe_deep_callback, callback, self.doc)
+        return self.integrated.observe_deep(_callback)
+
+    def unobserve(self, subscription: Subscription) -> None:
+        subscription.drop()
+
+
+def observe_callback(callback: Callable[[Any], None], doc: Doc, event: Any):
+    _event = event_types[type(event)](event, doc)
+    with doc._read_transaction(event.transaction):
+        callback(_event)
+
+
+def observe_deep_callback(callback: Callable[[Any], None], doc: Doc, events: list[Any]):
+    for idx, event in enumerate(events):
+        events[idx] = event_types[type(event)](event, doc)
+    with doc._read_transaction(event.transaction):
+        callback(events)
+
 
 class BaseEvent:
     __slots__ = ()

python/pycrdt/_doc.py

@@ -97,9 +97,7 @@ def _roots(self) -> dict[str, BaseType]:
                 key: (
                     None
                     if val is None
-                    else cast(Type[BaseType], base_types[type(val)])(
-                        _integrated=val, _doc=self
-                    )
+                    else cast(Type[BaseType], base_types[type(val)])(_integrated=val, _doc=self)
                 )
                 for key, val in self._doc.roots(txn._txn).items()
             }

python/pycrdt/_map.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-from functools import partial
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from ._base import BaseDoc, BaseEvent, BaseType, base_types, event_types
 from ._pycrdt import Map as _Map
@@ -140,34 +139,6 @@ def clear(self) -> None:
     def update(self, value: dict[str, Any]) -> None:
         self._init(value)
 
-    def observe(self, callback: Callable[[Any], None]) -> str:
-        _callback = partial(observe_callback, callback, self.doc)
-        return f"o_{self.integrated.observe(_callback)}"
-
-    def observe_deep(self, callback: Callable[[Any], None]) -> str:
-        _callback = partial(observe_deep_callback, callback, self.doc)
-        return f"od{self.integrated.observe_deep(_callback)}"
-
-    def unobserve(self, subscription_id: str) -> None:
-        sid = int(subscription_id[2:])
-        if subscription_id.startswith("o_"):
-            self.integrated.unobserve(sid)
-        else:
-            self.integrated.unobserve_deep(sid)
-
-
-def observe_callback(callback: Callable[[Any], None], doc: Doc, event: Any):
-    _event = event_types[type(event)](event, doc)
-    with doc._read_transaction(event.transaction):
-        callback(_event)
-
-
-def observe_deep_callback(callback: Callable[[Any], None], doc: Doc, events: list[Any]):
-    for idx, event in enumerate(events):
-        events[idx] = event_types[type(event)](event, doc)
-    with doc._read_transaction(event.transaction):
-        callback(events)
-
 
 class MapEvent(BaseEvent):
     __slots__ = "target", "keys", "path"

python/pycrdt/_pycrdt.pyi

@@ -45,6 +45,12 @@ class Doc:
         """Subscribes a callback to be called with the shared document subdoc change event.
         Returns a subscription ID that can be used to unsubscribe."""
 
+class Subscription:
+    """Observer subscription"""
+
+    def drop(self) -> None:
+        """Drop the subscription, effectively unobserving."""
+
 class Transaction:
     """Document transaction"""
 
@@ -94,13 +100,13 @@ class Text:
     def get_string(self, txn: Transaction) -> str:
         """Returns a text representation of the current shared text."""
 
-    def observe(self, callback: Callable[[TextEvent], None]) -> int:
+    def observe(self, callback: Callable[[TextEvent], None]) -> Subscription:
         """Subscribes a callback to be called with the shared text change event.
-        Returns a subscription ID that can be used to unsubscribe."""
+        Returns a subscription that can be used to unsubscribe."""
 
-    def unobserve(self, subscription_id: int) -> None:
+    def unobserve(self, subscription: Subscription) -> None:
         """Unsubscribes previously subscribed event callback identified by given
-        `subscription_id`."""
+        `subscription`."""
 
 class Array:
     """Shared array."""
@@ -123,18 +129,18 @@ class Array:
     def to_json(self, txn: Transaction) -> str:
         """Returns a JSON representation of the current array."""
 
-    def observe(self, callback: Callable[[TextEvent], None]) -> int:
+    def observe(self, callback: Callable[[TextEvent], None]) -> Subscription:
         """Subscribes a callback to be called with the array change event.
-        Returns a subscription ID that can be used to unsubscribe."""
+        Returns a subscription that can be used to unsubscribe."""
 
-    def observe_deep(self, callback: Callable[[TextEvent], None]) -> int:
+    def observe_deep(self, callback: Callable[[TextEvent], None]) -> Subscription:
         """Subscribes a callback to be called with the array change event
         and its nested elements.
-        Returns a subscription ID that can be used to unsubscribe."""
+        Returns a subscription that can be used to unsubscribe."""
 
-    def unobserve(self, subscription_id: int) -> None:
+    def unobserve(self, subscription: Subscription) -> None:
         """Unsubscribes previously subscribed event callback identified by given
-        `subscription_id`."""
+        `subscription`."""
 
 class Map:
     """Shared map."""
@@ -154,15 +160,15 @@ class Map:
     def to_json(self, txn: Transaction) -> str:
         """Returns a JSON representation of the current map."""
 
-    def observe(self, callback: Callable[[TextEvent], None]) -> int:
+    def observe(self, callback: Callable[[TextEvent], None]) -> Subscription:
         """Subscribes a callback to be called with the map change event.
-        Returns a subscription ID that can be used to unsubscribe."""
+        Returns a subscription that can be used to unsubscribe."""
 
-    def observe_deep(self, callback: Callable[[TextEvent], None]) -> int:
+    def observe_deep(self, callback: Callable[[TextEvent], None]) -> Subscription:
         """Subscribes a callback to be called with the map change event
         and its nested elements.
-        Returns a subscription ID that can be used to unsubscribe."""
+        Returns a subscription that can be used to unsubscribe."""
 
-    def unobserve(self, subscription_id: int) -> None:
+    def unobserve(self, subscription: Subscription) -> None:
         """Unsubscribes previously subscribed event callback identified by given
-        `subscription_id`."""
+        `subscription`."""

python/pycrdt/_text.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-from functools import partial
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING
 
 from ._base import BaseEvent, BaseType, base_types, event_types
 from ._pycrdt import Text as _Text
@@ -124,20 +123,6 @@ def insert(self, index: int, value: str) -> None:
         """Insert 'value' at character position 'index'."""
         self[index:index] = value
 
-    def observe(self, callback: Callable[[Any], None]) -> str:
-        _callback = partial(observe_callback, callback, self.doc)
-        return f"o_{self.integrated.observe(_callback)}"
-
-    def unobserve(self, subscription_id: str) -> None:
-        sid = int(subscription_id[2:])
-        self.integrated.unobserve(sid)
-
-
-def observe_callback(callback: Callable[[Any], None], doc: Doc, event: Any):
-    _event = event_types[type(event)](event, doc)
-    with doc._read_transaction(event.transaction):
-        callback(_event)
-
 
 class TextEvent(BaseEvent):
     __slots__ = "target", "delta", "path"

src/array.rs

@@ -15,6 +15,7 @@ use yrs::types::text::TextPrelim;
 use yrs::types::array::{ArrayPrelim, ArrayEvent as _ArrayEvent};
 use yrs::types::map::MapPrelim;
 use crate::transaction::Transaction;
+use crate::subscription::Subscription;
 use crate::type_conversions::{events_into_py, py_to_any, ToPython};
 use crate::text::Text;
 use crate::map::Map;
@@ -123,42 +124,32 @@ impl Array {
         Python::with_gil(|py| PyString::new(py, s.as_str()).into())
     }
 
-    pub fn observe(&mut self, f: PyObject) -> PyResult<u32> {
-        let id: u32 = self.array
+    pub fn observe(&mut self, py: Python<'_>, f: PyObject) -> PyResult<Py<Subscription>> {
+        let sub = self.array
             .observe(move |txn, e| {
                 Python::with_gil(|py| {
                     let event = ArrayEvent::new(e, txn);
                     if let Err(err) = f.call1(py, (event,)) {
                         err.restore(py)
                     }
                 })
-            })
-            .into();
-        Ok(id)
+            });
+        let s: Py<Subscription> = Py::new(py, Subscription::from(sub))?;
+        Ok(s)
     }
 
-    pub fn observe_deep(&mut self, f: PyObject) -> PyResult<u32> {
-        let id: u32 = self.array
+    pub fn observe_deep(&mut self, py: Python<'_>, f: PyObject) -> PyResult<Py<Subscription>> {
+        let sub = self.array
             .observe_deep(move |txn, events| {
                 Python::with_gil(|py| {
                     let events = events_into_py(txn, events);
                     if let Err(err) = f.call1(py, (events,)) {
                         err.restore(py)
                     }
                 })
-            })
-            .into();
-        Ok(id)
-    }
-
-    pub fn unobserve(&mut self, subscription_id: u32) -> PyResult<()> {
-        self.array.unobserve(subscription_id);
-        Ok(())
-    }
-
-    pub fn unobserve_deep(&mut self, subscription_id: u32) -> PyResult<()> {
-        self.array.unobserve_deep(subscription_id);
-        Ok(())
+            });
+        let s: Py<Subscription> = Py::new(py, Subscription::from(sub))?;
+        Ok(s)
     }
 }