pycrdt 0.12.37__tar.gz → 0.12.40__tar.gz

{pycrdt-0.12.37 → pycrdt-0.12.40}/.github/workflows/publish.yml

@@ -28,7 +28,7 @@ jobs:
       - name: Build wheels - universal2
         uses: PyO3/maturin-action@v1
         with:
-          args: --release --target universal2-apple-darwin --out dist -i 3.10 3.11 3.12 3.13 pypy3.10
+          args: --release --target universal2-apple-darwin --out dist -i 3.10 3.11 3.12 3.13 3.14 pypy3.10 pypy3.11
       - name: Test built wheel - universal2
         run: |
           pip install pytest pytest-mypy-testing "pydantic>=2.5.2,<3" "anyio>=4.4.0,<5" "trio>=0.25.1,<0.32" "exceptiongroup; python_version<'3.11'"
@@ -47,9 +47,9 @@ jobs:
       matrix:
         platform:
           - target: x64
-            interpreter: ["3.10", "3.11", "3.12", "3.13"]
+            interpreter: ["3.10", "3.11", "3.12", "3.13", "3.14"]
           - target: x86
-            interpreter: ["3.10", "3.11", "3.12", "3.13"]
+            interpreter: ["3.10", "3.11", "3.12", "3.13", "3.14"]
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
@@ -98,7 +98,7 @@ jobs:
           rust-toolchain: stable
           target: ${{ matrix.target }}
           manylinux: auto
-          args: --release --out dist -i 3.10 3.11 3.12 3.13 pypy3.10
+          args: --release --out dist -i 3.10 3.11 3.12 3.13 3.14 pypy3.10 pypy3.11
       - name: Test built wheel
         if: matrix.target == 'x86_64'
         run: |
@@ -127,7 +127,7 @@ jobs:
           rust-toolchain: stable
           target: ${{ matrix.target }}
           manylinux: auto
-          args: --release --out dist -i 3.10 3.11 3.12 3.13 pypy3.10
+          args: --release --out dist -i 3.10 3.11 3.12 3.13 3.14 pypy3.10 pypy3.11
 
       - uses: uraimo/run-on-arch-action@v2.8.1
         name: Test built wheel

{pycrdt-0.12.37 → pycrdt-0.12.40}/.github/workflows/test.yml

@@ -25,7 +25,9 @@ jobs:
           - '3.11'
           - '3.12'
           - '3.13'
+          - '3.14'
           - 'pypy3.10'
+          - 'pypy3.11'
 
     runs-on: ${{ matrix.os }}-latest
 

{pycrdt-0.12.37 → pycrdt-0.12.40}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Version history
 
+## 0.12.40
+
+- Support Python v3.14.
+
+## 0.12.38
+
+- Improve error propagation with `PyResult`.
+- Cleanup transaction when commit fails.
+
 ## 0.12.37
 
 - Drop Python 3.9 support.

{pycrdt-0.12.37 → pycrdt-0.12.40}/Cargo.lock

@@ -168,11 +168,10 @@ checksum = "58f929b4d672ea937a23a1ab494143d968337a5f47e56d0815df1e0890ddf174"
 
 [[package]]
 name = "lock_api"
-version = "0.4.13"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
 dependencies = [
- "autocfg",
  "scopeguard",
 ]
 
@@ -211,15 +210,15 @@ checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.11"
+version = "0.9.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
  "cfg-if",
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-targets",
+ "windows-link",
 ]
 
 [[package]]
@@ -245,7 +244,7 @@ dependencies = [
 
 [[package]]
 name = "pycrdt"
-version = "0.12.37"
+version = "0.12.40"
 dependencies = [
  "pyo3",
  "serde_json",
@@ -315,18 +314,18 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.40"
+version = "1.0.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.17"
+version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5407465600fb0548f1442edf71dd20683c6ed326200ace4b1ef0763521bb3b77"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
  "bitflags",
 ]
@@ -426,18 +425,18 @@ checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c"
 
 [[package]]
 name = "thiserror"
-version = "2.0.16"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3467d614147380f2e4e374161426ff399c91084acd2363eaf549172b3d5e60c0"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.16"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c5e1be1c48b9172ee610da68fd9cd2770e7a4056cb3fc98710ee6906f0c7960"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -522,68 +521,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
-dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
+name = "windows-link"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
 name = "yrs"

{pycrdt-0.12.37 → pycrdt-0.12.40}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pycrdt"
-version = "0.12.37"
+version = "0.12.40"
 edition = "2021"
 readme = "README.md"
 

{pycrdt-0.12.37 → pycrdt-0.12.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycrdt
-Version: 0.12.37
+Version: 0.12.40
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{pycrdt-0.12.37 → pycrdt-0.12.40}/docs/usage.md

@@ -88,13 +88,23 @@ CRDTs ensure that documents don't diverge, their shared documents will eventuall
 
 Every change to a shared data happens in a document transaction, and there can only be one transaction at a time. Pycrdt offers two methods for creating transactions:
 
-- `doc.transaction()`: used with a context manager, this will create a new transaction if there is no current one, or use the current transaction. This method will never block, and should be used most of the time.
+- `doc.transaction()`: used with a context manager or an async context manager, this will create a new transaction if there is no current one, or use the current transaction. This method will never block, and should be used most of the time.
 - `doc.new_transaction()`: used with a context manager or an async context manager, this will always try to create a new transaction. This method can block, waiting for a transaction to be released.
 
 ### Non-blocking transactions
 
-When no current transaction exists, an implicit transaction is created.
+#### Synchronous context manager
+
+When no current transaction exists, an implicit transaction is created:
+
+```py
+doc = Doc()
+text = doc.get("text", type=Text)
+text += "This change creates an implicit transaction"
+```
+
 Grouping multiple changes in a single transaction makes them atomic: they will appear as done simultaneously rather than sequentially.
+For performances, it is always better to try and group multiple changes in a single transaction.
 
 ```py
 with doc.transaction():
@@ -115,6 +125,26 @@ with doc.transaction() as t0:
             map0["key1"] = "value1"
 ```
 
+#### Asynchronous context manager
+
+Transactions created with an async context manager allow to register async callbacks when [observing document changes](#document-events). This makes
+it possible to apply back-pressure on document changes. With just synchronous callbacks, lots of document changes could be done
+without giving a chance to the event loop to send them over the wire, for instance. In the following example, the async context manager
+will not exit until the async callback is done:
+
+```py
+async def async_callback(event):
+    await send(event.update)
+
+doc.observe(async_callback)
+
+async with doc.transaction():
+    ...
+```
+
+Note that registering an async callback and creating a transaction with a synchronous context manager will result in an error.
+Also, it is not possible to have a nested async transaction while the root transaction is synchronous.
+
 ### Blocking transactions
 
 #### Multithreading

{pycrdt-0.12.37 → pycrdt-0.12.40}/python/pycrdt/_base.py

@@ -4,6 +4,7 @@ import threading
 from abc import ABC, abstractmethod
 from functools import lru_cache, partial
 from inspect import signature
+from types import UnionType
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -12,6 +13,8 @@ from typing import (
     Type,
     Union,
     cast,
+    get_args,
+    get_origin,
     get_type_hints,
     overload,
 )
@@ -388,10 +391,12 @@ class Typed:
             if key not in annotations:
                 raise AttributeError(f'"{type(self).mro()[0]}" has no attribute "{key}"')
             expected_type = annotations[key]
-            if hasattr(expected_type, "__origin__"):
-                expected_type = expected_type.__origin__
-            if hasattr(expected_type, "__args__"):
-                expected_types = expected_type.__args__
+            origin = get_origin(expected_type)
+            if origin in (Union, UnionType):
+                expected_types = get_args(expected_type)
+            elif origin is not None:
+                expected_type = origin
+                expected_types = (expected_type,)
             else:
                 expected_types = (expected_type,)
             if type(value) not in expected_types:

{pycrdt-0.12.37 → pycrdt-0.12.40}/python/pycrdt/_provider.py

@@ -141,10 +141,8 @@ class Provider:
         return self
 
     async def __aexit__(self, exc_type, exc_value, exc_tb):
-        try:
-            await self.stop()
-        finally:
-            return await self._exit_stack.__aexit__(exc_type, exc_value, exc_tb)
+        await self.stop()
+        return await self._exit_stack.__aexit__(exc_type, exc_value, exc_tb)
 
     @asynccontextmanager
     async def _get_or_create_task_group(self) -> AsyncIterator[TaskGroup]:

{pycrdt-0.12.37 → pycrdt-0.12.40}/python/pycrdt/_transaction.py

@@ -73,16 +73,18 @@ class Transaction:
         # since nested transactions reuse the root transaction
         if self._leases == 0:
             assert self._txn is not None
-            if not isinstance(self, ReadTransaction):
-                self._txn.commit()
-                origin_hash = self._txn.origin()
-                if origin_hash is not None:
-                    del self._doc._origins[origin_hash]
-                if self._doc._allow_multithreading:
-                    self._doc._txn_lock.release()
-            self._txn.drop()
-            self._txn = None
-            self._doc._txn = None
+            try:
+                if not isinstance(self, ReadTransaction):
+                    self._txn.commit()
+                    origin_hash = self._txn.origin()
+                    if origin_hash is not None:
+                        del self._doc._origins[origin_hash]
+                    if self._doc._allow_multithreading:
+                        self._doc._txn_lock.release()
+            finally:
+                self._txn.drop()
+                self._txn = None
+                self._doc._txn = None
 
     async def __aenter__(self, _acquire_transaction: bool = True) -> Transaction:
         if self._leases > 0 and self._doc._task_group is None:

{pycrdt-0.12.37 → pycrdt-0.12.40}/src/doc.rs

@@ -68,18 +68,24 @@ impl Doc {
 #[pymethods]
 impl Doc {
     #[new]
-    fn new(client_id: &Bound<'_, PyAny>, skip_gc: &Bound<'_, PyAny>) -> Self {
+    fn new(client_id: &Bound<'_, PyAny>, skip_gc: &Bound<'_, PyAny>) -> PyResult<Self> {
         let mut options = Options::default();
         if !client_id.is_none() {
-            let _client_id: u64 = client_id.downcast::<PyInt>().unwrap().extract().unwrap();
+            let _client_id: u64 = client_id.downcast::<PyInt>()
+                .map_err(|_| PyValueError::new_err("client_id must be an integer"))?
+                .extract()
+                .map_err(|_| PyValueError::new_err("client_id must be a valid u64"))?;
             options.client_id = _client_id;
         }
         if !skip_gc.is_none() {
-            let _skip_gc: bool = skip_gc.downcast::<PyBool>().unwrap().extract().unwrap();
+            let _skip_gc: bool = skip_gc.downcast::<PyBool>()
+                .map_err(|_| PyValueError::new_err("skip_gc must be a boolean"))?
+                .extract()
+                .map_err(|_| PyValueError::new_err("skip_gc must be a valid bool"))?;
             options.skip_gc = _skip_gc;
         }
         let doc = _Doc::with_options(options);
-        Doc { doc }
+        Ok(Doc { doc })
     }
 
     #[staticmethod]
@@ -161,7 +167,8 @@ impl Doc {
     }
 
     fn apply_update(&mut self, txn: &mut Transaction, update: &Bound<'_, PyBytes>) -> PyResult<()> {
-        let u = Update::decode_v1(update.as_bytes()).unwrap();
+        let u = Update::decode_v1(update.as_bytes())
+            .map_err(|e| PyValueError::new_err(format!("Cannot decode update: {}", e)))?;
         let mut _t = txn.transaction();
         let t = _t.as_mut().unwrap().as_mut();
         t.apply_update(u)
@@ -251,13 +258,13 @@ impl TransactionEvent {
 #[pymethods]
 impl TransactionEvent {
     #[getter]
-    pub fn transaction<'py>(&mut self, py: Python<'py>) -> Bound<'py, PyAny> {
+    pub fn transaction<'py>(&mut self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         if let Some(transaction) = &self.transaction {
-            transaction.clone_ref(py).into_bound(py)
+            Ok(transaction.clone_ref(py).into_bound(py))
         } else {
-            let transaction = Transaction::from(self.txn()).into_bound_py_any(py).unwrap();
+            let transaction = Transaction::from(self.txn()).into_bound_py_any(py)?;
             self.transaction = Some(transaction.clone().unbind());
-            transaction
+            Ok(transaction)
         }
     }
 

{pycrdt-0.12.37 → pycrdt-0.12.40}/src/map.rs

@@ -94,7 +94,8 @@ impl Map {
     fn insert_doc(&self, txn: &mut Transaction, key: &str, doc: &Bound<'_, PyAny>) -> PyResult<()> {
         let mut _t = txn.transaction();
         let mut t = _t.as_mut().unwrap().as_mut();
-        let d1: Doc = doc.extract().unwrap();
+        let d1: Doc = doc.extract()
+            .map_err(|_| PyTypeError::new_err("Expected Doc object"))?;
         let d2: _Doc = d1.doc;
         let doc_ref = self.map.insert(&mut t, key, d2);
         doc_ref.load(t);
@@ -215,24 +216,24 @@ impl MapEvent {
 #[pymethods]
 impl MapEvent {
     #[getter]
-    pub fn transaction<'py>(&mut self, py: Python<'py>) -> Bound<'py, PyAny> {
+    pub fn transaction<'py>(&mut self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         if let Some(transaction) = &self.transaction {
-            transaction.clone_ref(py).into_bound(py)
+            Ok(transaction.clone_ref(py).into_bound(py))
         } else {
-            let transaction = Transaction::from(self.txn()).into_bound_py_any(py).unwrap();
+            let transaction = Transaction::from(self.txn()).into_bound_py_any(py)?;
             self.transaction = Some(transaction.clone().unbind());
-            transaction
+            Ok(transaction)
         }
     }
 
     #[getter]
-    pub fn target<'py>(&mut self, py: Python<'py>) -> Bound<'py, PyAny> {
+    pub fn target<'py>(&mut self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         if let Some(target) = &self.target {
-            target.clone_ref(py).into_bound(py)
+            Ok(target.clone_ref(py).into_bound(py))
         } else {
-            let target = Map::from(self.event().target().clone()).into_bound_py_any(py).unwrap();
+            let target = Map::from(self.event().target().clone()).into_bound_py_any(py)?;
             self.target = Some(target.clone().unbind());
-            target
+            Ok(target)
         }
     }
 
@@ -248,9 +249,9 @@ impl MapEvent {
     }
 
     #[getter]
-    pub fn keys<'py>(&mut self, py: Python<'py>) -> Bound<'py, PyAny> {
+    pub fn keys<'py>(&mut self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         if let Some(keys) = &self.keys {
-            keys.clone_ref(py).into_bound(py)
+            Ok(keys.clone_ref(py).into_bound(py))
         } else {
             let keys = {
                 let keys = self.event().keys(self.txn());
@@ -258,20 +259,20 @@ impl MapEvent {
                 for (key, value) in keys.iter() {
                     let key = &**key;
                     let value = EntryChangeWrapper(value);
-                    result.set_item(key, value.into_pyobject(py).unwrap()).unwrap();
+                    result.set_item(key, value.into_pyobject(py)?)?;
                 }
                 result
             };
-            let keys = keys.into_bound_py_any(py).unwrap();
+            let keys = keys.into_bound_py_any(py)?;
             self.keys = Some(keys.clone().unbind());
-            keys
+            Ok(keys)
         }
     }
 
-    fn __repr__(&mut self, py: Python<'_>) -> String {
-        let target = self.target(py);
-        let keys = self.keys(py);
+    fn __repr__(&mut self, py: Python<'_>) -> PyResult<String> {
+        let target = self.target(py)?;
+        let keys = self.keys(py)?;
         let path = self.path(py);
-        format!("MapEvent(target={target}, keys={keys}, path={path})")
+        Ok(format!("MapEvent(target={target}, keys={keys}, path={path})"))
     }
 }

{pycrdt-0.12.37 → pycrdt-0.12.40}/src/transaction.rs

@@ -52,8 +52,13 @@ impl Transaction {
 
 #[pymethods]
 impl Transaction {
-    pub fn commit(&mut self) {
+    pub fn commit(&mut self, py: Python<'_>) -> PyResult<()> {
         self.transaction().as_mut().unwrap().as_mut().commit();
+        // Check if any Python exception was raised during commit (e.g., in callbacks)
+        if let Some(err) = pyo3::PyErr::take(py) {
+            return Err(err);
+        }
+        Ok(())
     }
 
     pub fn drop(&self) {

{pycrdt-0.12.37 → pycrdt-0.12.40}/tests/test_doc.py

@@ -231,6 +231,25 @@ def test_get_update_exception():
     assert str(excinfo.value) == "Cannot decode state"
 
 
+def test_apply_update_exception():
+    doc = Doc()
+    with pytest.raises(ValueError) as excinfo:
+        doc.apply_update(b"\xFF\xFF\xFF\xFF")
+    assert "Cannot decode update" in str(excinfo.value)
+
+
+def test_invalid_client_id():
+    with pytest.raises(ValueError) as excinfo:
+        Doc(client_id="not_an_int")
+    assert "client_id must be" in str(excinfo.value)
+
+
+def test_invalid_skip_gc():
+    with pytest.raises(ValueError) as excinfo:
+        Doc(skip_gc="not_a_bool")
+    assert "skip_gc must be" in str(excinfo.value)
+
+
 async def test_iterate_events():
     doc = Doc()
     updates = []

{pycrdt-0.12.37 → pycrdt-0.12.40}/tests/test_transaction.py

@@ -326,12 +326,10 @@ async def test_async_callback_in_sync_transaction():
     doc.observe(async_callback)
     text = doc.get("text", type=Text)
 
-    with pytest.raises(SystemError) as excinfo:
+    with pytest.raises(RuntimeError) as excinfo:
         with doc.transaction():
             text += "hello"
-    if platform.python_implementation() != "PyPy":  # pragma: nocover
-        assert isinstance(excinfo.value.__context__, RuntimeError)
-        assert str(excinfo.value.__context__) == "Async callback in non-async transaction"
+    assert str(excinfo.value) == "Async callback in non-async transaction"
 
 
 async def test_async_transaction_in_existing_async_transaction():