Adjust code and examples to PyO3 0.16 API changes.

Author: adamreichold

README.md

@@ -70,16 +70,16 @@ fn rust_ext(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     ) -> &'py PyArrayDyn<f64> {
         let x = x.as_array();
         let y = y.as_array();
-        axpy(a, x, y).into_pyarray(py)
+        let z = axpy(a, x, y);
+        z.into_pyarray(py)
     }
 
     // wrapper of `mult`
     #[pyfn(m)]
     #[pyo3(name = "mult")]
-    fn mult_py(_py: Python<'_>, a: f64, x: &PyArrayDyn<f64>) -> PyResult<()> {
+    fn mult_py(_py: Python<'_>, a: f64, x: &PyArrayDyn<f64>) {
         let x = unsafe { x.as_array_mut() };
         mult(a, x);
-        Ok(())
     }
 
     Ok(())

src/array.rs

@@ -922,7 +922,7 @@ impl<D: Dimension> PyArray<PyObject, D> {
     ///
     ///     let pyarray = PyArray::from_owned_object_array(py, array);
     ///
-    ///     assert!(pyarray.readonly().get(0).unwrap().as_ref(py).is_instance::<CustomElement>().unwrap());
+    ///     assert!(pyarray.readonly().get(0).unwrap().as_ref(py).is_instance_of::<CustomElement>().unwrap());
     /// });
     /// ```
     pub fn from_owned_object_array<'py, T>(py: Python<'py>, arr: Array<Py<T>, D>) -> &'py Self {

src/dtype.rs

@@ -498,13 +498,15 @@ mod tests {
     #[test]
     fn test_dtype_new() {
         Python::with_gil(|py| {
-            assert_eq!(PyArrayDescr::new(py, "float64").unwrap(), dtype::<f64>(py));
+            assert!(PyArrayDescr::new(py, "float64")
+                .unwrap()
+                .is(dtype::<f64>(py)));
 
             let dt = PyArrayDescr::new(py, [("a", "O"), ("b", "?")].as_ref()).unwrap();
             assert_eq!(dt.names(), Some(vec!["a", "b"]));
             assert!(dt.has_object());
-            assert_eq!(dt.get_field("a").unwrap().0, dtype::<PyObject>(py));
-            assert_eq!(dt.get_field("b").unwrap().0, dtype::<bool>(py));
+            assert!(dt.get_field("a").unwrap().0.is(dtype::<PyObject>(py)));
+            assert!(dt.get_field("b").unwrap().0.is(dtype::<bool>(py)));
 
             assert!(PyArrayDescr::new(py, &123_usize).is_err());
         });

src/slice_container.rs

@@ -1,11 +1,13 @@
 use std::{mem, slice};
 
 use ndarray::{ArrayBase, Dimension, OwnedRepr};
-use pyo3::class::impl_::{PyClassImpl, ThreadCheckerStub};
-use pyo3::pyclass::PyClass;
-use pyo3::pyclass_slots::PyClassDummySlot;
-use pyo3::type_object::{LazyStaticType, PyTypeInfo};
-use pyo3::{ffi, types::PyAny, PyCell, Python};
+use pyo3::{
+    ffi,
+    impl_::pyclass::{PyClassDummySlot, PyClassImpl, PyClassItems, ThreadCheckerStub},
+    pyclass::PyClass,
+    type_object::{LazyStaticType, PyTypeInfo},
+    PyAny, PyCell, Python,
+};
 
 /// Utility type to safely store `Box<[_]>` or `Vec<_>` on the Python heap
 pub(crate) struct PySliceContainer {
@@ -95,6 +97,8 @@ impl PyClassImpl for PySliceContainer {
     type BaseType = PyAny;
     type Layout = PyCell<Self>;
     type ThreadChecker = ThreadCheckerStub<Self>;
+
+    fn for_all_items(_visitor: &mut dyn FnMut(&PyClassItems)) {}
 }
 
 unsafe impl PyTypeInfo for PySliceContainer {

tests/array.rs

@@ -120,8 +120,8 @@ fn as_slice() {
 fn is_instance() {
     pyo3::Python::with_gil(|py| {
         let arr = PyArray2::<f64>::zeros(py, [3, 5], false);
-        assert!(arr.is_instance::<PyArray2<f64>>().unwrap());
-        assert!(!arr.is_instance::<PyList>().unwrap());
+        assert!(arr.is_instance_of::<PyArray2<f64>>().unwrap());
+        assert!(!arr.is_instance_of::<PyList>().unwrap());
     })
 }