Python: Upgrade to Pyo3 0.26

Author: tronical

api/python/slint/Cargo.toml

@@ -46,7 +46,7 @@ i-slint-backend-selector = { workspace = true }
 i-slint-core = { workspace = true }
 slint-interpreter = { workspace = true, features = ["default", "display-diagnostics", "internal"] }
 i-slint-compiler = { workspace = true }
-pyo3 = { version = "0.25", features = ["extension-module", "indexmap", "chrono", "abi3-py311"] }
+pyo3 = { version = "0.26", features = ["extension-module", "indexmap", "chrono", "abi3-py311"] }
 indexmap = { version = "2.1.0" }
 chrono = "0.4"
 spin_on = { workspace = true }

api/python/slint/interpreter.rs

@@ -409,7 +409,7 @@ impl ComponentInstance {
         ))
     }
 
-    fn set_callback(&self, name: &str, callable: PyObject) -> Result<(), PySetCallbackError> {
+    fn set_callback(&self, name: &str, callable: Py<PyAny>) -> Result<(), PySetCallbackError> {
         let rust_cb = self.callbacks.register(name.to_string(), callable);
         Ok(self.instance.set_callback(name, rust_cb)?.into())
     }
@@ -418,7 +418,7 @@ impl ComponentInstance {
         &mut self,
         global_name: &str,
         callback_name: &str,
-        callable: PyObject,
+        callable: Py<PyAny>,
     ) -> Result<(), PySetCallbackError> {
         let rust_cb = self
             .global_callbacks
@@ -458,12 +458,12 @@ impl ComponentInstance {
 }
 
 struct GcVisibleCallbacks {
-    callables: Rc<RefCell<HashMap<String, PyObject>>>,
+    callables: Rc<RefCell<HashMap<String, Py<PyAny>>>>,
     type_collection: TypeCollection,
 }
 
 impl GcVisibleCallbacks {
-    fn register(&self, name: String, callable: PyObject) -> impl Fn(&[Value]) -> Value + 'static {
+    fn register(&self, name: String, callable: Py<PyAny>) -> impl Fn(&[Value]) -> Value + 'static {
         self.callables.borrow_mut().insert(name.clone(), callable);
 
         let callables = self.callables.clone();
@@ -472,7 +472,7 @@ impl GcVisibleCallbacks {
         move |args| {
             let callables = callables.borrow();
             let callable = callables.get(&name).unwrap();
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 let py_args =
                     PyTuple::new(py, args.iter().map(|v| type_collection.to_py_value(v.clone())))
                         .unwrap();

api/python/slint/models.rs

@@ -15,7 +15,7 @@ use crate::value::{SlintToPyValue, TypeCollection};
 
 pub struct PyModelShared {
     notify: ModelNotify,
-    self_ref: RefCell<Option<PyObject>>,
+    self_ref: RefCell<Option<Py<PyAny>>>,
     /// The type collection is needed when calling a Python implementation of set_row_data and
     /// the model data provided (for example from within a .slint file) contains an enum. Then
     /// we need to know how to map it to the correct Python enum. This field is lazily set, whenever
@@ -56,7 +56,7 @@ impl PyModelBase {
         }
     }
 
-    fn init_self(&self, self_ref: PyObject) {
+    fn init_self(&self, self_ref: Py<PyAny>) {
         *self.inner.self_ref.borrow_mut() = Some(self_ref);
     }
 
@@ -88,7 +88,7 @@ impl i_slint_core::model::Model for PyModelShared {
     type Data = slint_interpreter::Value;
 
     fn row_count(&self) -> usize {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let obj = self.self_ref.borrow();
             let Some(obj) = obj.as_ref() else {
                 eprintln!("Python: Model implementation is lacking self object (in row_count)");
@@ -115,7 +115,7 @@ impl i_slint_core::model::Model for PyModelShared {
     }
 
     fn row_data(&self, row: usize) -> Option<Self::Data> {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let obj = self.self_ref.borrow();
             let Some(obj) = obj.as_ref() else {
                 eprintln!("Python: Model implementation is lacking self object (in row_data)");
@@ -148,7 +148,7 @@ impl i_slint_core::model::Model for PyModelShared {
     }
 
     fn set_row_data(&self, row: usize, data: Self::Data) {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let obj = self.self_ref.borrow();
             let Some(obj) = obj.as_ref() else {
                 eprintln!("Python: Model implementation is lacking self object (in set_row_data)");

api/python/slint/timer.rs

@@ -65,13 +65,13 @@ impl PyTimer {
         &self,
         mode: PyTimerMode,
         interval: chrono::Duration,
-        callback: PyObject,
+        callback: Py<PyAny>,
     ) -> PyResult<()> {
         let interval = interval
             .to_std()
             .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?;
         self.timer.start(mode.into(), interval, move || {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 callback.call0(py).expect("unexpected failure running python timer callback");
             });
         });
@@ -85,12 +85,12 @@ impl PyTimer {
     /// * `duration`: The duration from now until when the timer should fire.
     /// * `callback`: The function to call when the time has been reached or exceeded.
     #[staticmethod]
-    fn single_shot(duration: chrono::Duration, callback: PyObject) -> PyResult<()> {
+    fn single_shot(duration: chrono::Duration, callback: Py<PyAny>) -> PyResult<()> {
         let duration = duration
             .to_std()
             .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?;
         i_slint_core::timers::Timer::single_shot(duration, move || {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 callback.call0(py).expect("unexpected failure running python timer callback");
             });
         });

api/python/slint/value.rs

@@ -79,7 +79,7 @@ impl PyStruct {
             |value| Ok(self.type_collection.to_py_value(value.clone())),
         )
     }
-    fn __setattr__(&mut self, py: Python<'_>, key: String, value: PyObject) -> PyResult<()> {
+    fn __setattr__(&mut self, py: Python<'_>, key: String, value: Py<PyAny>) -> PyResult<()> {
         let pv =
             TypeCollection::slint_value_from_py_value(py, &value, Some(&self.type_collection))?;
         self.data.set_field(key, pv);
@@ -123,12 +123,12 @@ impl PyStructFieldIterator {
 }
 
 thread_local! {
-    static ENUM_CLASS: OnceCell<PyObject> = OnceCell::new();
+    static ENUM_CLASS: OnceCell<Py<PyAny>> = OnceCell::new();
 }
 
-pub fn enum_class(py: Python) -> PyObject {
+pub fn enum_class(py: Python) -> Py<PyAny> {
     ENUM_CLASS.with(|cls| {
-        cls.get_or_init(|| -> PyObject {
+        cls.get_or_init(|| -> Py<PyAny> {
             let enum_module = py.import("enum").unwrap();
             enum_module.getattr("Enum").unwrap().into()
         })
@@ -141,7 +141,7 @@ pub fn enum_class(py: Python) -> PyObject {
 /// a `.slint` file loaded with load_file. This is used to map enums
 /// provided by Slint to the correct python enum classes.
 pub struct TypeCollection {
-    enum_classes: Rc<HashMap<String, PyObject>>,
+    enum_classes: Rc<HashMap<String, Py<PyAny>>>,
 }
 
 impl TypeCollection {
@@ -193,7 +193,7 @@ impl TypeCollection {
         enum_name: &str,
         enum_value: &str,
         py: Python<'_>,
-    ) -> Result<PyObject, PyErr> {
+    ) -> Result<Py<PyAny>, PyErr> {
         let enum_cls = self.enum_classes.get(enum_name).ok_or_else(|| {
             PyErr::new::<pyo3::exceptions::PyTypeError, _>(format!(
                 "Slint provided enum {enum_name} is unknown"
@@ -209,13 +209,13 @@ impl TypeCollection {
         crate::models::ReadOnlyRustModel { model: model.clone(), type_collection: self.clone() }
     }
 
-    pub fn enums(&self) -> impl Iterator<Item = (&String, &PyObject)> {
+    pub fn enums(&self) -> impl Iterator<Item = (&String, &Py<PyAny>)> {
         self.enum_classes.iter()
     }
 
     pub fn slint_value_from_py_value(
         py: Python<'_>,
-        ob: &PyObject,
+        ob: &Py<PyAny>,
         type_collection: Option<&Self>,
     ) -> PyResult<slint_interpreter::Value> {
         Self::slint_value_from_py_value_bound(&ob.bind(py), type_collection)