Update for upcoming PyO3 0.9.0

Author: kngwyu

Cargo.toml

@@ -15,7 +15,7 @@ libc = "0.2"
 num-complex = "0.2"
 num-traits = "0.2"
 ndarray = ">=0.13"
-pyo3 = "0.9.0-alpha.1"
+pyo3 = "0.9.0"
 
 [features]
 # In default setting, python version is automatically detected

README.md

@@ -56,7 +56,7 @@ using [setuptools-rust](https://github.com/PyO3/setuptools-rust).
 name = "numpy-test"
 
 [dependencies]
-pyo3 = "0.9.0-alpha.1"
+pyo3 = "0.9.0"
 numpy = "0.7.0"
 ```
 

examples/linalg/Cargo.toml

@@ -10,9 +10,9 @@ crate-type = ["cdylib"]
 
 [dependencies]
 numpy = { path = "../.." }
-ndarray = ">= 0.12"
-ndarray-linalg = { version = "0.10", features = ["openblas"] }
+ndarray = ">= 0.13"
+ndarray-linalg = { version = "0.12", features = ["openblas"] }
 
 [dependencies.pyo3]
-version = "0.9.0-alpha.1"
+version = "0.9.0"
 features = ["extension-module"]

examples/simple-extension/Cargo.toml

@@ -13,5 +13,5 @@ numpy = { path = "../.." }
 ndarray = ">= 0.12"
 
 [dependencies.pyo3]
-version = "0.9.0-alpha.1"
+version = "0.9.0"
 features = ["extension-module"]

src/array.rs

@@ -99,8 +99,8 @@ pub fn get_array_module(py: Python<'_>) -> PyResult<&PyModule> {
     PyModule::import(py, npyffi::array::MOD_NAME)
 }
 
-impl<T, D> type_object::PyObjectLayout<PyArray<T, D>> for npyffi::PyArrayObject {}
-impl<T, D> type_object::PyObjectSizedLayout<PyArray<T, D>> for npyffi::PyArrayObject {}
+unsafe impl<T, D> type_object::PyLayout<PyArray<T, D>> for npyffi::PyArrayObject {}
+impl<T, D> type_object::PySizedLayout<PyArray<T, D>> for npyffi::PyArrayObject {}
 
 pyobject_native_type_convert!(
     PyArray<T, D>,
@@ -170,7 +170,7 @@ impl<T, D> PyArray<T, D> {
     /// let not_contiguous: &numpy::PyArray1<f32> = py
     ///     .eval("np.zeros((3, 5))[::2, 4]", Some(locals), None)
     ///     .unwrap()
-    ///     .downcast_ref()
+    ///     .downcast()
     ///     .unwrap();
     /// assert!(!not_contiguous.is_contiguous());
     /// # }
@@ -390,19 +390,23 @@ impl<T: TypeNum, D: Dimension> PyArray<T, D> {
         ID: IntoDimension<Dim = D>,
     {
         let dims = dims.into_dimension();
-        let container = SliceBox::new(py, slice).expect("SliceBox creation failed");
+        let container = SliceBox::new(slice);
+        let data_ptr = container.data;
+        let cell = pyo3::PyClassInitializer::from(container)
+            .create_cell(py)
+            .expect("Object creation failed.");
         let ptr = PY_ARRAY_API.PyArray_New(
             PY_ARRAY_API.get_type_object(npyffi::ArrayType::PyArray_Type),
             dims.ndim_cint(),
             dims.as_dims_ptr(),
             T::typenum_default(),
             strides as *mut _,          // strides
-            (*container).data as _,     // data
+            data_ptr as _,              // data
             mem::size_of::<T>() as i32, // itemsize
             0,                          // flag
             ::std::ptr::null_mut(),     //obj
         );
-        PY_ARRAY_API.PyArray_SetBaseObject(ptr as *mut npyffi::PyArrayObject, container as _);
+        PY_ARRAY_API.PyArray_SetBaseObject(ptr as *mut npyffi::PyArrayObject, cell as _);
         Self::from_owned_ptr(py, ptr)
     }
 
@@ -455,7 +459,7 @@ impl<T: TypeNum, D: Dimension> PyArray<T, D> {
     /// let not_contiguous: &PyArray1<f32> = py
     ///     .eval("np.zeros((3, 5))[[0, 2], [3, 4]]", Some(locals), None)
     ///     .unwrap()
-    ///     .downcast_ref()
+    ///     .downcast()
     ///     .unwrap();
     /// assert!(not_contiguous.as_slice().is_err());
     /// # }

src/slice_box.rs

@@ -1,21 +1,17 @@
 use pyo3::class::methods::{PyMethodDefType, PyMethodsProtocol};
-use pyo3::pyclass::{PyClass, PyClassAlloc, PyClassShell};
+use pyo3::pyclass::{PyClass, PyClassAlloc};
 use pyo3::pyclass_slots::PyClassDummySlot;
-use pyo3::{ffi, type_object, types::PyAny, PyClassInitializer, PyResult, Python};
+use pyo3::{ffi, type_object, types::PyAny, PyCell, PyClassInitializer};
 
 pub(crate) struct SliceBox<T> {
     pub(crate) data: *mut [T],
 }
 
 impl<T> SliceBox<T> {
-    pub(crate) unsafe fn new(
-        py: Python<'_>,
-        value: Box<[T]>,
-    ) -> PyResult<*mut PyClassShell<SliceBox<T>>> {
-        let value = SliceBox {
+    pub(crate) fn new(value: Box<[T]>) -> Self {
+        SliceBox {
             data: Box::into_raw(value),
-        };
-        PyClassInitializer::from(value).create_shell(py)
+        }
     }
 }
 
@@ -30,22 +26,26 @@ impl<T> PyClassAlloc for SliceBox<T> {}
 impl<T> PyClass for SliceBox<T> {
     type Dict = PyClassDummySlot;
     type WeakRef = PyClassDummySlot;
+    type BaseNativeType = PyAny;
 }
 
-impl<T> type_object::PyTypeInfo for SliceBox<T> {
+unsafe impl<T> type_object::PyTypeInfo for SliceBox<T> {
     type Type = ();
     type BaseType = PyAny;
-    type ConcreteLayout = PyClassShell<Self>;
+    type BaseLayout = pyo3::pycell::PyCellBase<PyAny>;
+    type Layout = PyCell<Self>;
     type Initializer = PyClassInitializer<Self>;
+    type AsRefTarget = PyCell<Self>;
     const NAME: &'static str = "SliceBox";
     const MODULE: Option<&'static str> = Some("_rust_numpy");
     const DESCRIPTION: &'static str = "Memory store for PyArray using rust's Box<[T]>.";
     const FLAGS: usize = 0;
 
     #[inline]
-    unsafe fn type_object() -> &'static mut ffi::PyTypeObject {
-        static mut TYPE_OBJECT: ::pyo3::ffi::PyTypeObject = ::pyo3::ffi::PyTypeObject_INIT;
-        &mut TYPE_OBJECT
+    fn type_object() -> &'static ffi::PyTypeObject {
+        use pyo3::type_object::LazyStaticType;
+        static TYPE_OBJECT: LazyStaticType = LazyStaticType::new();
+        TYPE_OBJECT.get_or_init::<Self>()
     }
 }
 

tests/array.rs

@@ -17,7 +17,7 @@ fn not_contiguous_array<'py>(py: Python<'py>) -> &'py PyArray1<i32> {
         None,
     )
     .unwrap()
-    .downcast_ref()
+    .downcast()
     .unwrap()
 }