Update PyO3 to 0.9.0

Author: kngwyu

Cargo.toml

@@ -14,8 +14,8 @@ cfg-if = "0.1"
 libc = "0.2"
 num-complex = "0.2"
 num-traits = "0.2"
-ndarray = ">=0.12"
-pyo3 = "0.8"
+ndarray = ">=0.13"
+pyo3 = { git = "https://github.com/PyO3/pyo3.git" }
 
 [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.8"
+pyo3 = "0.9.0-alpha.1"
 numpy = "0.7.0"
 ```
 
@@ -102,7 +102,7 @@ numpy = "0.7.0"
 ndarray = "0.13"
 
 [dependencies.pyo3]
-version = "0.8"
+version = "0.9.0-alpha.1"
 features = ["extension-module"]
 ```
 

examples/linalg/Cargo.toml

@@ -14,5 +14,5 @@ ndarray = ">= 0.12"
 ndarray-linalg = { version = "0.10", features = ["openblas"] }
 
 [dependencies.pyo3]
-version = "0.8"
+version = "0.9.0-alpha.1"
 features = ["extension-module"]

examples/simple-extension/Cargo.toml

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

src/array.rs

@@ -2,7 +2,7 @@
 use crate::npyffi::{self, npy_intp, NPY_ORDER, PY_ARRAY_API};
 use ndarray::*;
 use num_traits::AsPrimitive;
-use pyo3::{ffi, prelude::*, types::PyAny};
+use pyo3::{ffi, prelude::*, type_object, types::PyAny};
 use pyo3::{AsPyPointer, PyDowncastError, PyNativeType};
 use std::iter::ExactSizeIterator;
 use std::marker::PhantomData;
@@ -99,8 +99,12 @@ 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 {}
+
 pyobject_native_type_convert!(
     PyArray<T, D>,
+    npyffi::PyArrayObject,
     *npyffi::PY_ARRAY_API.get_type_object(npyffi::ArrayType::PyArray_Type),
     Some("numpy"),
     npyffi::PyArray_Check,
@@ -386,19 +390,19 @@ impl<T: TypeNum, D: Dimension> PyArray<T, D> {
         ID: IntoDimension<Dim = D>,
     {
         let dims = dims.into_dimension();
-        let slice = SliceBox::new(slice);
+        let container = SliceBox::new(py, slice).expect("SliceBox 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
-            slice.data(),               // data
+            (*container).data 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, slice.as_ptr());
+        PY_ARRAY_API.PyArray_SetBaseObject(ptr as *mut npyffi::PyArrayObject, container as _);
         Self::from_owned_ptr(py, ptr)
     }
 

src/slice_box.rs

@@ -1,39 +1,47 @@
 use pyo3::class::methods::{PyMethodDefType, PyMethodsProtocol};
-use pyo3::{ffi, type_object, types::PyAny, AsPyPointer, PyObjectAlloc, Python};
-use std::os::raw::c_void;
+use pyo3::pyclass::{PyClass, PyClassAlloc, PyClassShell};
+use pyo3::pyclass_slots::PyClassDummySlot;
+use pyo3::{ffi, type_object, types::PyAny, PyClassInitializer, PyResult, Python};
 
-/// It's a memory store for IntoPyArray.
-/// See IntoPyArray's doc for what concretely this type is for.
-#[repr(C)]
 pub(crate) struct SliceBox<T> {
-    ob_base: ffi::PyObject,
-    inner: *mut [T],
+    pub(crate) data: *mut [T],
 }
 
 impl<T> SliceBox<T> {
-    pub(crate) unsafe fn new<'a>(box_: Box<[T]>) -> &'a Self {
-        let type_ob = <Self as type_object::PyTypeObject>::init_type().as_ptr();
-        let base = ffi::_PyObject_New(type_ob);
-        *base = ffi::PyObject_HEAD_INIT;
-        (*base).ob_type = type_ob;
-        let self_ = base as *mut SliceBox<T>;
-        (*self_).inner = Box::into_raw(box_);
-        &*self_
+    pub(crate) unsafe fn new(
+        py: Python<'_>,
+        value: Box<[T]>,
+    ) -> PyResult<*mut PyClassShell<SliceBox<T>>> {
+        let value = SliceBox {
+            data: Box::into_raw(value),
+        };
+        PyClassInitializer::from(value).create_shell(py)
     }
-    pub(crate) fn data(&self) -> *mut c_void {
-        self.inner as *mut c_void
+}
+
+impl<T> Drop for SliceBox<T> {
+    fn drop(&mut self) {
+        let _boxed_slice = unsafe { Box::from_raw(self.data) };
     }
 }
 
+impl<T> PyClassAlloc for SliceBox<T> {}
+
+impl<T> PyClass for SliceBox<T> {
+    type Dict = PyClassDummySlot;
+    type WeakRef = PyClassDummySlot;
+}
+
 impl<T> type_object::PyTypeInfo for SliceBox<T> {
     type Type = ();
     type BaseType = PyAny;
+    type ConcreteLayout = PyClassShell<Self>;
+    type Initializer = PyClassInitializer<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;
-    const SIZE: usize = std::mem::size_of::<Self>();
-    const OFFSET: isize = 0;
+
     #[inline]
     unsafe fn type_object() -> &'static mut ffi::PyTypeObject {
         static mut TYPE_OBJECT: ::pyo3::ffi::PyTypeObject = ::pyo3::ffi::PyTypeObject_INIT;
@@ -46,24 +54,3 @@ impl<T> PyMethodsProtocol for SliceBox<T> {
         Vec::new()
     }
 }
-
-impl<T> AsPyPointer for SliceBox<T> {
-    #[inline]
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        &self.ob_base as *const _ as *mut _
-    }
-}
-
-impl<T> PyObjectAlloc for SliceBox<T> {
-    /// Calls the rust destructor for the object.
-    unsafe fn drop(py: Python<'_>, obj: *mut ffi::PyObject) {
-        let data = (*(obj as *mut SliceBox<T>)).inner;
-        let boxed_slice = Box::from_raw(data);
-        drop(boxed_slice);
-        <Self as type_object::PyTypeInfo>::BaseType::drop(py, obj);
-    }
-    unsafe fn dealloc(py: Python<'_>, obj: *mut ffi::PyObject) {
-        Self::drop(py, obj);
-        ffi::PyObject_Free(obj as *mut c_void);
-    }
-}