update pyo3

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tiny-solver"
-version = "0.4.1"
+version = "0.5.0"
 edition = "2021"
 authors = ["Powei Lin <poweilin1994@gmail.com>"]
 readme = "README.md"
@@ -19,19 +19,19 @@ faer = "0.18.2"
 faer-ext = { version = "0.1.0", features = ["nalgebra"] }
 log = "0.4.21"
 nalgebra = "0.32.4"
-num-dual = "0.8.1"
+num-dual = "0.9.0"
 num-traits = "0.2.18"
-numpy = { version = "0.20.0", features = ["nalgebra"], optional = true }
-pyo3 = { version = "0.20.3", features = ["abi3", "abi3-py38"] }
-pyo3-log = { version = "0.9.0", optional = true }
+numpy = { version = "0.21.0", features = ["nalgebra"], optional = true }
+pyo3 = { version = "0.21.0", features = ["abi3", "abi3-py38"] }
+# pyo3-log = { version = "0.9.0", optional = true }
 rayon = "1.9.0"
 
 [[example]]
 name = "m3500_benchmark"
 path = "examples/m3500_benchmark.rs"
 
 [features]
-python = ["num-dual/python", "numpy", "pyo3-log"]
+python = ["num-dual/python", "numpy"]
 
 [dev-dependencies]
 env_logger = "0.11.3"

src/python/mod.rs

@@ -10,36 +10,40 @@ mod py_optimizer;
 mod py_problem;
 use self::py_factors::*;
 
-fn register_child_module(py: Python<'_>, parent_module: &PyModule) -> PyResult<()> {
+fn register_child_module(parent_module: &Bound<'_, PyModule>) -> PyResult<()> {
     // For factors submodule
-    let factors_module = PyModule::new(py, "factors")?;
+    let factors_module = PyModule::new_bound(parent_module.py(), "factors")?;
     factors_module.add_class::<BetweenFactorSE2>()?;
     factors_module.add_class::<PriorFactor>()?;
     factors_module.add_class::<PyFactor>()?;
-    parent_module.add_submodule(factors_module)?;
-    py.import("sys")?
+    parent_module.add_submodule(&factors_module)?;
+    parent_module
+        .py()
+        .import_bound("sys")?
         .getattr("modules")?
         .set_item("tiny_solver.factors", factors_module)?;
 
-    let loss_functions_module = PyModule::new(py, "loss_functions")?;
+    let loss_functions_module = PyModule::new_bound(parent_module.py(), "loss_functions")?;
     loss_functions_module.add_class::<HuberLoss>()?;
-    parent_module.add_submodule(loss_functions_module)?;
-    py.import("sys")?
+    parent_module.add_submodule(&loss_functions_module)?;
+    parent_module
+        .py()
+        .import_bound("sys")?
         .getattr("modules")?
         .set_item("tiny_solver.loss_functions", loss_functions_module)?;
     Ok(())
 }
 
 /// A Python module implemented in Rust.
 #[pymodule]
-pub fn tiny_solver<'py>(_py: Python<'py>, m: &'py PyModule) -> PyResult<()> {
-    pyo3_log::init();
+pub fn tiny_solver(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    // pyo3_log::init();
     m.add("__version__", env!("CARGO_PKG_VERSION"))?;
     m.add_class::<Problem>()?;
     m.add_class::<LinearSolver>()?;
     m.add_class::<OptimizerOptions>()?;
     m.add_class::<GaussNewtonOptimizer>()?;
-    register_child_module(_py, m)?;
+    register_child_module(m)?;
 
     Ok(())
 }

src/python/py_factors.rs

@@ -62,7 +62,7 @@ impl Factor for PyFactor {
                 })
                 .map(|x| x.into_py(py))
                 .collect();
-            let args = PyTuple::new(py, py_params);
+            let args = PyTuple::new_bound(py, py_params);
             let result = self.func.call1(py, args);
             let residual_py = result.unwrap().extract::<Vec<PyDual64Dyn>>(py);
             residual_py

src/python/py_optimizer.rs

@@ -23,7 +23,7 @@ impl GaussNewtonOptimizer {
         &self,
         py: Python<'_>,
         problem: &Problem,
-        initial_values: &PyDict,
+        initial_values: &Bound<'_, PyDict>,
         optimizer_options: Option<OptimizerOptions>,
     ) -> PyResult<HashMap<String, Py<PyArray2<f64>>>> {
         let init_values: HashMap<String, PyReadonlyArray1<f64>> = initial_values.extract().unwrap();
@@ -35,7 +35,7 @@ impl GaussNewtonOptimizer {
 
         let output_d: HashMap<String, Py<PyArray2<f64>>> = result
             .iter()
-            .map(|(k, v)| (k.to_string(), v.to_pyarray(py).to_owned().into()))
+            .map(|(k, v)| (k.to_string(), v.to_pyarray_bound(py).to_owned().into()))
             .collect();
         Ok(output_d)
     }

src/python/py_problem.rs

@@ -6,7 +6,7 @@ use crate::problem::Problem;
 
 use super::PyFactor;
 
-fn convert_pyany_to_factor(py_any: &PyAny) -> PyResult<(bool, Box<dyn Factor + Send>)> {
+fn convert_pyany_to_factor(py_any: &Bound<'_, PyAny>) -> PyResult<(bool, Box<dyn Factor + Send>)> {
     let factor_name: String = py_any.get_type().getattr("__name__")?.extract()?;
     match factor_name.as_str() {
         "BetweenFactorSE2" => {
@@ -26,7 +26,9 @@ fn convert_pyany_to_factor(py_any: &PyAny) -> PyResult<(bool, Box<dyn Factor + S
         )),
     }
 }
-fn convert_pyany_to_loss_function(py_any: &PyAny) -> PyResult<Option<Box<dyn Loss + Send>>> {
+fn convert_pyany_to_loss_function(
+    py_any: &Bound<'_, PyAny>,
+) -> PyResult<Option<Box<dyn Loss + Send>>> {
     let factor_name: String = py_any.get_type().getattr("__name__")?.extract()?;
     match factor_name.as_str() {
         "HuberLoss" => {
@@ -52,8 +54,8 @@ impl Problem {
         &mut self,
         dim_residual: usize,
         variable_key_size_list: Vec<(String, usize)>,
-        pyfactor: &PyAny,
-        pyloss_func: &PyAny,
+        pyfactor: &Bound<'_, PyAny>,
+        pyloss_func: &Bound<'_, PyAny>,
     ) -> PyResult<()> {
         let (is_pyfactor, factor) = convert_pyany_to_factor(pyfactor).unwrap();
         self.add_residual_block(