Apply all changes from y-crdt#156

Author: ahonko

.gitignore

@@ -9,4 +9,5 @@ Cargo.lock
 docs/_*
 .DS_Store
 *.pyc
-dist
+dist
+.idea

Cargo.toml

@@ -4,15 +4,17 @@ version = "0.7.0-alpha.1"
 rust-version = "1.72"
 edition = "2021"
 
+[features]
+sync = []
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [lib]
 name = "y_py"
 crate-type = ["cdylib"]
 
 [dependencies]
-lib0 = "0.16.10"
-yrs = "0.16.10"
+yrs = "0.21.3"
 
 [dependencies.pyo3]
 version = "0.19.2"

pyproject.toml

@@ -5,6 +5,7 @@ build-backend = "maturin"
 [project]
 name = "y-py"
 description = "Python bindings for the Y-CRDT built from yrs (Rust)"
+dynamic = ["version"]
 license = { file = "LICENSE" }
 authors = [
     { name = "John Waidhofer", email = "[email protected]" },

src/json_builder.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, convert::TryFrom};
 
-use lib0::any::Any;
 use pyo3::{exceptions::PyTypeError, PyErr, PyObject, PyResult, Python};
+use yrs::Any;
 
 use crate::shared_types::{CompatiblePyType, YPyType};
 

src/shared_types.rs

@@ -16,7 +16,7 @@ use std::{
     rc::Rc,
 };
 use yrs::types::TypeRef;
-use yrs::SubscriptionId;
+use yrs::Subscription;
 
 // Common errors
 create_exception!(y_py, PreliminaryObservationException, PyException, "Occurs when an observer is attached to a Y type that is not integrated into a YDoc. Y types can only be observed once they have been added to a YDoc.");
@@ -45,17 +45,14 @@ impl DefaultPyErr for IntegratedOperationException {
 }
 
 #[pyclass]
-#[derive(Clone, Copy)]
-pub struct ShallowSubscription(pub SubscriptionId);
-#[pyclass]
-#[derive(Clone, Copy)]
-pub struct DeepSubscription(pub SubscriptionId);
+#[cfg(feature = "sync")]
+#[derive(Clone)]
+pub struct ObservationId(pub Subscription);
 
-#[derive(FromPyObject)]
-pub enum SubId {
-    Shallow(ShallowSubscription),
-    Deep(DeepSubscription),
-}
+#[pyclass(unsendable)]
+#[cfg(not(feature = "sync"))]
+#[derive(Clone)]
+pub struct ObservationId(pub Subscription);
 
 #[derive(Clone)]
 pub enum CompatiblePyType<'a> {

src/type_conversions.rs

@@ -1,4 +1,3 @@
-use lib0::any::Any;
 use pyo3::create_exception;
 use pyo3::exceptions::PyException;
 use pyo3::exceptions::PyTypeError;
@@ -13,13 +12,15 @@ use std::ops::Deref;
 use std::rc::Rc;
 use yrs::block::Unused;
 use yrs::block::{ItemContent, Prelim};
+use yrs::branch::{Branch, BranchPtr};
 use yrs::types::Events;
-use yrs::types::{Attrs, Branch, BranchPtr, Change, Delta, Value};
+use yrs::types::{Attrs, Change, Delta};
+use yrs::Any;
 use yrs::ArrayRef;
 use yrs::MapRef;
 use yrs::TextRef;
 use yrs::TransactionMut;
-use yrs::{Array, Map, Text};
+use yrs::{Array, Map, Out, Text};
 
 use crate::shared_types::CompatiblePyType;
 use crate::shared_types::TypeWithDoc;
@@ -131,7 +132,7 @@ impl WithDocToPython for &Attrs {
         let o = pytypes::PyDict::new(py);
         for (key, value) in self.iter() {
             let key = key.as_ref();
-            let value = Value::Any(value.clone()).with_doc_into_py(doc.clone(), py);
+            let value = Out::Any(value.clone()).with_doc_into_py(doc.clone(), py);
             o.set_item(key, value).unwrap();
         }
         o.into()
@@ -311,7 +312,7 @@ impl<'a> TryFrom<CompatiblePyType<'a>> for Any {
         const MAX_JS_NUMBER: i64 = 2_i64.pow(53) - 1;
         match py_type {
             CompatiblePyType::Bool(b) => Ok(Any::Bool(b.extract()?)),
-            CompatiblePyType::String(s) => Ok(Any::String(s.extract::<String>()?.into_boxed_str())),
+            CompatiblePyType::String(s) => Ok(Any::String(s.extract::<String>()?.into())),
             CompatiblePyType::Int(i) => {
                 let num: i64 = i.extract()?;
                 if num > MAX_JS_NUMBER {
@@ -326,7 +327,7 @@ impl<'a> TryFrom<CompatiblePyType<'a>> for Any {
                     .into_iter()
                     .map(|py_any|CompatiblePyType::try_from(py_any)?.try_into())
                     .collect();
-                result.map(|res| Any::Array(res.into_boxed_slice()))
+                result.map(|res| Any::Array(res.into()))
             },
             CompatiblePyType::Dict(d) => {
                 let result: PyResult<HashMap<String, Any>> = d
@@ -337,7 +338,7 @@ impl<'a> TryFrom<CompatiblePyType<'a>> for Any {
                         Ok((key, value))
                     })
                     .collect();
-                result.map(|res| Any::Map(Box::new(res)))
+                result.map(|res| Any::Map(Box::new(res).into()))
             },
             CompatiblePyType::None => Ok(Any::Null),
             CompatiblePyType::YType(v) => Err(MultipleIntegrationError::new_err(format!(
@@ -416,17 +417,17 @@ impl ToPython for Any {
     }
 }
 
-impl WithDocToPython for Value {
+impl WithDocToPython for Out {
     fn with_doc_into_py(self, doc: Rc<RefCell<YDocInner>>, py: Python) -> PyObject {
         match self {
-            Value::Any(v) => v.into_py(py),
-            Value::YText(v) => v.with_doc(doc).into_py(py),
-            Value::YArray(v) => v.with_doc(doc).into_py(py),
-            Value::YMap(v) => v.with_doc(doc).into_py(py),
-            Value::YXmlElement(v) => v.with_doc(doc).into_py(py),
-            Value::YXmlText(v) => v.with_doc(doc).into_py(py),
-            Value::YXmlFragment(v) => v.with_doc(doc).into_py(py),
-            Value::YDoc(_) => py.None(),
+            Out::Any(v) => v.into_py(py),
+            Out::YText(v) => v.with_doc(doc).into_py(py),
+            Out::YArray(v) => v.with_doc(doc).into_py(py),
+            Out::YMap(v) => v.with_doc(doc).into_py(py),
+            Out::YXmlElement(v) => v.with_doc(doc).into_py(py),
+            Out::YXmlText(v) => v.with_doc(doc).into_py(py),
+            Out::YXmlFragment(v) => v.with_doc(doc).into_py(py),
+            _ => py.None(),
         }
     }
 }

src/y_array.rs

@@ -1,27 +1,26 @@
-use std::cell::RefCell;
-use std::convert::{TryFrom, TryInto};
-use std::rc::Rc;
-
 use crate::json_builder::JsonBuilder;
 use crate::shared_types::{
-    CompatiblePyType, DeepSubscription, DefaultPyErr, PreliminaryObservationException,
-    ShallowSubscription, SubId, TypeWithDoc,
+    CompatiblePyType, DefaultPyErr, ObservationId, PreliminaryObservationException, TypeWithDoc,
 };
 use crate::type_conversions::{events_into_py, WithDocToPython};
 use crate::y_doc::{WithDoc, YDocInner};
 use crate::y_transaction::{YTransaction, YTransactionInner};
+use std::cell::RefCell;
+use std::clone::Clone;
+use std::convert::{TryFrom, TryInto};
+use std::rc::Rc;
+use std::string::ToString;
 
 use super::shared_types::SharedType;
 use crate::type_conversions::ToPython;
-use lib0::any::Any;
 use pyo3::exceptions::PyIndexError;
 
 use crate::type_conversions::PyObjectWrapper;
 use pyo3::prelude::*;
 use pyo3::types::{PyList, PySlice, PySliceIndices};
 use yrs::types::array::ArrayEvent;
 use yrs::types::{DeepObservable, ToJson};
-use yrs::{Array, ArrayRef, Assoc, Observable, SubscriptionId, TransactionMut};
+use yrs::{Any, Array, ArrayRef, Assoc, Observable, TransactionMut};
 
 /// A collection used to store data in an indexed sequence structure. This type is internally
 /// implemented as a double linked list, which may squash values inserted directly one after another
@@ -365,59 +364,55 @@ impl YArray {
 
     /// Subscribes to all operations happening over this instance of `YArray`. All changes are
     /// batched and eventually triggered during transaction commit phase.
-    /// Returns a `SubscriptionId` which can be used to cancel the callback with `unobserve`.
-    pub fn observe(&mut self, f: PyObject) -> PyResult<ShallowSubscription> {
+    /// Returns a `ObservationId` which can be used to cancel the callback with `unobserve`.
+    pub fn observe(&mut self, f: PyObject) -> PyResult<ObservationId> {
         match &mut self.0 {
             SharedType::Integrated(array) => {
                 let doc = array.doc.clone();
-                let sub: SubscriptionId = array
-                    .inner
-                    .observe(move |txn, e| {
-                        Python::with_gil(|py| {
-                            let event = YArrayEvent::new(e, txn, doc.clone());
-                            if let Err(err) = f.call1(py, (event,)) {
-                                err.restore(py)
-                            }
-                        })
+                let subscription = array.inner.observe(move |txn, e| {
+                    Python::with_gil(|py| {
+                        let event = YArrayEvent::new(e, txn, doc.clone());
+                        if let Err(err) = f.call1(py, (event,)) {
+                            err.restore(py)
+                        }
                     })
-                    .into();
-                Ok(ShallowSubscription(sub))
+                });
+                Ok(ObservationId(subscription))
             }
             SharedType::Prelim(_) => Err(PreliminaryObservationException::default_message()),
         }
     }
     /// Observes YArray events and events of all child elements.
-    pub fn observe_deep(&mut self, f: PyObject) -> PyResult<DeepSubscription> {
+    pub fn observe_deep(&mut self, f: PyObject) -> PyResult<ObservationId> {
         match &mut self.0 {
             SharedType::Integrated(array) => {
                 let doc = array.doc.clone();
-                let sub: SubscriptionId = array
-                    .inner
-                    .observe_deep(move |txn, events| {
-                        Python::with_gil(|py| {
-                            let events = events_into_py(txn, events, doc.clone());
-                            if let Err(err) = f.call1(py, (events,)) {
-                                err.restore(py)
-                            }
-                        })
+                let subscription = array.inner.observe_deep(move |txn, events| {
+                    Python::with_gil(|py| {
+                        let events = events_into_py(txn, events, doc.clone());
+                        if let Err(err) = f.call1(py, (events,)) {
+                            err.restore(py)
+                        }
                     })
-                    .into();
-                Ok(DeepSubscription(sub))
+                });
+                Ok(ObservationId(subscription))
             }
             SharedType::Prelim(_) => Err(PreliminaryObservationException::default_message()),
         }
     }
 
-    /// Cancels the callback of an observer using the Subscription ID returned from the `observe` method.
-    pub fn unobserve(&mut self, subscription_id: SubId) -> PyResult<()> {
+    /// Cancels the callback of an observer using the `observation_d` returned from the `observe` method.
+    pub fn unobserve(&mut self, observation_d: ObservationId) -> PyResult<()> {
         match &mut self.0 {
-            SharedType::Integrated(arr) => {
-                match subscription_id {
-                    SubId::Shallow(ShallowSubscription(id)) => arr.unobserve(id),
-                    SubId::Deep(DeepSubscription(id)) => arr.unobserve_deep(id),
-                }
-                Ok(())
-            }
+            SharedType::Integrated(_) => Ok(drop(observation_d.0)),
+            SharedType::Prelim(_) => Err(PreliminaryObservationException::default_message()),
+        }
+    }
+
+    /// Cancels the callback of an observer using the `observation_d` returned from the `observe_deep` method.
+    pub fn unobserve_deep(&mut self, observation_d: ObservationId) -> PyResult<()> {
+        match &mut self.0 {
+            SharedType::Integrated(_) => Ok(drop(observation_d.0)),
             SharedType::Prelim(_) => Err(PreliminaryObservationException::default_message()),
         }
     }