Bumpver and migrate to pyo3 0.24.2

Author: Divy1211

.github/workflows/CI.yml

@@ -1,6 +1,6 @@
 [package]
 name = "bfp-rs"
-version = "0.3.0-alpha17"
+version = "0.3.0-alpha18"
 edition = "2021"
 
 [profile.release]
@@ -23,7 +23,7 @@ name = "bfp_rs"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = "0.22.0"
+pyo3 = "0.24.2"
 encoding_rs = "0.8.35"
 indicatif = "0.17.11"
 serde = "1.0.219"

Cargo.lock

@@ -53,7 +53,7 @@ pub mod combinators;
 pub mod help;
 
 fn le(py: Python, types: &Bound<PyModule>) -> PyResult<()> {
-    let le = PyModule::new_bound(types.py(), "bfp_rs.types.le")?;
+    let le = PyModule::new(types.py(), "bfp_rs.types.le")?;
     py_run!(py, le, "import sys; sys.modules['bfp_rs.types.le'] = le");
     types.add_submodule(&le)?;
 
@@ -136,7 +136,7 @@ fn le(py: Python, types: &Bound<PyModule>) -> PyResult<()> {
 }
 
 fn types(py: Python, bfp: &Bound<PyModule>) -> PyResult<()> {
-    let types = PyModule::new_bound(bfp.py(), "bfp_rs.types")?;
+    let types = PyModule::new(bfp.py(), "bfp_rs.types")?;
     py_run!(py, types, "import sys; sys.modules['bfp_rs.types'] = types");
     bfp.add_submodule(&types)?;
 
@@ -146,7 +146,7 @@ fn types(py: Python, bfp: &Bound<PyModule>) -> PyResult<()> {
 }
 
 fn combinators(py: Python, bfp: &Bound<PyModule>) -> PyResult<()> {
-    let combinators = &PyModule::new_bound(bfp.py(), "bfp_rs.combinators")?;
+    let combinators = &PyModule::new(bfp.py(), "bfp_rs.combinators")?;
     py_run!(py, combinators, "import sys; sys.modules['bfp_rs.combinators'] = combinators");
     bfp.add_submodule(combinators)?;
 
@@ -170,20 +170,20 @@ fn combinators(py: Python, bfp: &Bound<PyModule>) -> PyResult<()> {
 }
 
 fn errors(py: Python, bfp: &Bound<PyModule>) -> PyResult<()> {
-    let errors = PyModule::new_bound(bfp.py(), "bfp_rs.errors")?;
+    let errors = PyModule::new(bfp.py(), "bfp_rs.errors")?;
     py_run!(py, errors, "import sys; sys.modules['bfp_rs.errors'] = errors");
     bfp.add_submodule(&errors)?;
-    errors.add("ParsingError", py.get_type_bound::<ParsingError>())?;
-    errors.add("CompressionError", py.get_type_bound::<CompressionError>())?;
-    errors.add("DefaultValueError", py.get_type_bound::<DefaultAttributeError>())?;
-    errors.add("VersionError", py.get_type_bound::<VersionError>())?;
-    errors.add("MutabilityError", py.get_type_bound::<MutabilityError>())?;
+    errors.add("ParsingError", py.get_type::<ParsingError>())?;
+    errors.add("CompressionError", py.get_type::<CompressionError>())?;
+    errors.add("DefaultValueError", py.get_type::<DefaultAttributeError>())?;
+    errors.add("VersionError", py.get_type::<VersionError>())?;
+    errors.add("MutabilityError", py.get_type::<MutabilityError>())?;
 
     Ok(())
 }
 
 fn diff(py: Python, bfp: &Bound<PyModule>) -> PyResult<()> {
-    let diff = PyModule::new_bound(bfp.py(), "bfp_rs.diff")?;
+    let diff = PyModule::new(bfp.py(), "bfp_rs.diff")?;
     py_run!(py, diff, "import sys; sys.modules['bfp_rs.diff'] = diff");
     bfp.add_submodule(&diff)?;
 

Cargo.toml

@@ -6,7 +6,7 @@ macro_rules! wrap_py {
             #[pyo3(name = "to_bytes")]
             fn to_bytes_py(slf: PyRef<Self>, value: <Self as Parseable>::Type) -> PyResult<Bound<PyBytes>> {
                 let bytes = slf.to_bytes(&value)?;
-                Ok(PyBytes::new_bound(slf.py(), &bytes))
+                Ok(PyBytes::new(slf.py(), &bytes))
             }
 
             #[pyo3(name = "from_stream", signature = (stream, ver = Version::new(vec![0,])))]

src/lib.rs

@@ -190,7 +190,7 @@ impl Retriever {
                         "List length mismatch for '{}' which is a retriever of fixed repeat. Expected: {repeat}, Actual: {len}", slf.name
                     )))
                 }
-                let value = value.iter()?
+                let value = value.try_iter()?
                     .map(|v| {
                         slf.data_type.to_parseable(&v.expect("obtained from python"))
                     }).collect::<PyResult<Vec<_>>>()?;
@@ -231,9 +231,9 @@ impl Retriever {
 
         if let Some(default_factory) = self.default_factory.as_ref() {
             let first_default = default_factory
-                .call_bound(py, (ver.clone(),) , None)
+                .call(py, (ver.clone(),) , None)
                 .or_else(|_err| {
-                    default_factory.call_bound(py, (ver.clone(), ctx.clone()) , None)
+                    default_factory.call(py, (ver.clone(), ctx.clone()) , None)
                 })?
                 .into_bound(py);
             if state == RetState::Value {
@@ -260,9 +260,9 @@ impl Retriever {
 
             for _ in 1..repeat {
                 let default = default_factory
-                    .call_bound(py, (ver.clone(),), None)
+                    .call(py, (ver.clone(),), None)
                     .or_else(|_err| {
-                        default_factory.call_bound(py, (ver.clone(), ctx.clone()) , None)
+                        default_factory.call(py, (ver.clone(), ctx.clone()) , None)
                     })?
                     .into_bound(py);
                 ls.push(self.data_type.to_parseable(&default)?);

src/macros/wrap_py.rs

@@ -1,4 +1,5 @@
 use std::cell::OnceCell;
+use std::ffi::CString;
 use std::sync::Arc;
 use pyo3::exceptions::{PyTypeError, PyValueError};
 use pyo3::intern;
@@ -45,8 +46,8 @@ impl RetrieverRef {
         let enum_ = match r#enum {
             None => None,
             Some(cls) => {
-                let globals = PyDict::new_bound(cls.py());
-                cls.py().run_bound("from enum import Enum", Some(&globals), None)?;
+                let globals = PyDict::new(cls.py());
+                cls.py().run(&CString::new("from enum import Enum")?, Some(&globals), None)?;
                 let enum_cls = globals.get_item("Enum")?.expect("infallible");
 
                 if !cls.is_subclass(&enum_cls)? {
@@ -132,10 +133,10 @@ impl RetrieverRef {
         Ok(current)
     }
 
-    fn __set__(
-        slf: Bound<Self>,
-        mut instance: Bound<PyAny>,
-        mut value: Bound<PyAny>,
+    fn __set__<'py>(
+        slf: Bound<'py, Self>,
+        mut instance: Bound<'py, PyAny>,
+        mut value: Bound<'py, PyAny>,
     ) -> PyResult<()> {
         let this = slf.borrow();
         if let Some(cls) = &this.enum_ {

src/retrievers/retriever.rs

@@ -97,9 +97,9 @@ impl BaseStruct {
 
     // todo: figure out unsafe allocations
     pub fn with_cls<'py>(val: BaseStruct, cls: &Bound<'py, PyType>) -> PyResult<Bound<'py, PyAny>> {
-        let kwargs = PyDict::new_bound(cls.py());
-        kwargs.set_item("ver", Version::new(vec![-1]).into_py(cls.py()))?;
-        kwargs.set_item("ctx", ContextPtr::new().into_py(cls.py()))?;
+        let kwargs = PyDict::new(cls.py());
+        kwargs.set_item("ver", Version::new(vec![-1]).into_pyobject(cls.py())?)?;
+        kwargs.set_item("ctx", ContextPtr::new().into_pyobject(cls.py())?)?;
         kwargs.set_item("init_defaults", false)?;
         let obj = cls.call_method(intern!(cls.py(), "__new__"), (cls,), Some(&kwargs))?;
         let name = intern!(cls.py(), "__reconstruct__");
@@ -223,10 +223,13 @@ impl BaseStruct {
     #[classmethod]
     fn retrievers<'py>(cls: &Bound<'py, PyType>) -> PyResult<Bound<'py, PyList>> {
         let struct_ = StructBuilder::get_struct(&cls)?;
-        Ok(PyList::new_bound(
+        PyList::new(
             cls.py(),
-            struct_.retrievers().iter().map(|x| x.clone().into_py(cls.py()))
-        ))
+            struct_.retrievers()
+                .iter()
+                .map(|x| x.clone().into_pyobject(cls.py()))
+                .collect::<Result<Vec<_>, _>>()?
+        )
     }
 
     #[new]
@@ -315,7 +318,7 @@ impl BaseStruct {
         if struct_.is_compressed() {
             struct_.compress(&mut bytes, 0)?;
         }
-        Ok(PyBytes::new_bound(cls.py(), &bytes).into_any())
+        Ok(PyBytes::new(cls.py(), &bytes).into_any())
     }
 
     #[classmethod]

src/retrievers/retriever_ref.rs

@@ -6,7 +6,7 @@ use std::sync::RwLock;
 use pyo3::exceptions::{PyIndexError, PyTypeError, PyValueError};
 use pyo3::prelude::{PyAnyMethods, PyDictMethods, PyTypeMethods};
 use pyo3::types::{PyDict, PyInt, PySlice, PySliceIndices, PySliceMethods};
-use pyo3::{pyclass, pymethods, Bound, IntoPy, PyAny, PyRef, PyRefMut, PyResult, Python};
+use pyo3::{pyclass, pymethods, Bound, IntoPyObjectExt, PyAny, PyRef, PyRefMut, PyResult, Python};
 use serde::{Serialize, Serializer};
 use crate::errors::mutability_error::MutabilityError;
 use crate::types::bfp_type::BfpType;
@@ -93,7 +93,7 @@ impl BfpList {
             return Err(MutabilityError::new_err("This list is set as immutable by it's API designer"));
         }
 
-        let mut vals = val.iter()?
+        let mut vals = val.try_iter()?
             .map(|v| {
                 inner.data_type.to_parseable(&v.expect("obtained from python"))
             })
@@ -259,8 +259,7 @@ impl BfpList {
                 idxes.into_iter()
                     .map(|idx| inner.data[idx].clone().to_bound(slf.py()))
                     .collect::<PyResult<Vec<_>>>()?
-                    .into_py(slf.py())
-                    .into_bound(slf.py())
+                    .into_bound_py_any(slf.py())?
             )
         }
         Err(PyIndexError::new_err(
@@ -287,7 +286,7 @@ impl BfpList {
             let item = item.downcast_into::<PySlice>().expect("infallible");
             let idxes = slice(item.indices(inner.data.len() as isize)?)?;
 
-            let vals = val.iter()?
+            let vals = val.try_iter()?
                 .map(|v| v.expect("obtained from python"))
                 .collect::<Vec<_>>();
             if idxes.len() != vals.len() {
@@ -479,7 +478,7 @@ impl BfpList {
 
 impl BfpList {
     pub fn diffs_to_dict<'py>(&self, changes: Vec<IDiff<ParseableType>>, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
-        let di = PyDict::new_bound(py);
+        let di = PyDict::new(py);
         let inner = self.inner();
         for (idx, change) in changes {
             PyDictMethods::set_item(
@@ -492,7 +491,7 @@ impl BfpList {
     }
 
     pub fn conflicts_to_dict<'py>(&self, conflicts: Vec<Conflict<ParseableType>>, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
-        let di = PyDict::new_bound(py);
+        let di = PyDict::new(py);
         let mut inner = self.inner_mut();
         for conflict in conflicts {
             let idx = conflict.idx();

src/types/base_struct.rs

@@ -398,7 +398,7 @@ impl BfpType {
     #[pyo3(name = "to_bytes")]
     fn to_bytes_py<'py>(slf: PyRef<'py, Self>, value: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyBytes>> {
         let bytes = slf.to_bytes(&slf.to_parseable(value)?)?;
-        Ok(PyBytes::new_bound(slf.py(), &bytes))
+        Ok(PyBytes::new(slf.py(), &bytes))
     }
 
     #[pyo3(name = "from_stream", signature = (stream, ver = Version::new(vec![0,])))]