Adjust code and examples to PyO3 0.16 API changes.

Author: adamreichold

README.md

@@ -45,8 +45,8 @@ numpy = "0.15"
 
 ```rust
 use numpy::ndarray::{ArrayD, ArrayViewD, ArrayViewMutD};
-use numpy::{IntoPyArray, PyArrayDyn, PyReadonlyArrayDyn};
-use pyo3::prelude::{pymodule, PyModule, PyResult, Python};
+use numpy::{Complex64, IntoPyArray, PyArrayDyn, PyReadonlyArrayDyn};
+use pyo3::{pymodule, types::PyModule, PyResult, Python};
 
 #[pymodule]
 fn rust_ext(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
@@ -61,7 +61,8 @@ fn rust_ext(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     }
 
     // wrapper of `axpy`
-    #[pyfn(m, "axpy")]
+    #[pyfn(m)]
+    #[pyo3(name = "axpy")]
     fn axpy_py<'py>(
         py: Python<'py>,
         a: f64,
@@ -70,15 +71,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, "mult")]
-    fn mult_py(_py: Python<'_>, a: f64, x: &PyArrayDyn<f64>) -> PyResult<()> {
+    #[pyfn(m)]
+    #[pyo3(name = "mult")]
+    fn mult_py(_py: Python<'_>, a: f64, x: &PyArrayDyn<f64>) {
         let x = unsafe { x.as_array_mut() };
         mult(a, x);
-        Ok(())
     }
 
     Ok(())
@@ -98,8 +100,7 @@ numpy = "0.15"
 
 ```rust
 use numpy::PyArray1;
-use pyo3::prelude::{PyResult, Python};
-use pyo3::types::IntoPyDict;
+use pyo3::{types::IntoPyDict, PyResult, Python};
 
 fn main() -> PyResult<()> {
     Python::with_gil(|py| {

src/array.rs

@@ -904,7 +904,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/slice_container.rs

@@ -1,11 +1,14 @@
 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};
+use pyo3::{
+    class::impl_::{PyClassImpl, ThreadCheckerStub},
+    ffi,
+    impl_::pyclass::PyClassDummySlot,
+    pyclass::PyClass,
+    type_object::{LazyStaticType, PyTypeInfo},
+    PyAny, PyCell,
+};
 
 /// Utility type to safely store Box<[_]> or Vec<_> on the Python heap
 pub(crate) struct 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());
     })
 }