Merge pull request #93 from stefan-k/bump_pyo3_version

bump to 0.6.0 (broken)

Author: kngwyu

Cargo.toml

@@ -14,7 +14,7 @@ libc = "0.2.44"
 num-complex = "0.2.1"
 num-traits = "0.2.6"
 ndarray = "0.12"
-pyo3 = "0.5.3"
+pyo3 = "0.6.0"
 
 [features]
 # In default setting, python version is automatically detected

README.md

@@ -115,9 +115,9 @@ extern crate pyo3;
 
 use ndarray::{ArrayD, ArrayViewD, ArrayViewMutD};
 use numpy::{IntoPyArray, PyArrayDyn};
-use pyo3::prelude::{pymodinit, Py, PyModule, PyResult, Python};
+use pyo3::prelude::{pymodule, Py, PyModule, PyResult, Python};
 
-#[pymodinit]
+#[pymodule]
 fn rust_ext(_py: Python, m: &PyModule) -> PyResult<()> {
     // immutable example
     fn axpy(a: f64, x: ArrayViewD<f64>, y: ArrayViewD<f64>) -> ArrayD<f64> {

examples/linalg/Cargo.toml

@@ -14,5 +14,5 @@ ndarray = "0.12"
 ndarray-linalg = { version = "0.10", features = ["openblas"] }
 
 [dependencies.pyo3]
-version = "0.5.3"
+version = "0.6.0"
 features = ["extension-module"]

examples/linalg/src/lib.rs

@@ -1,14 +1,14 @@
 use ndarray_linalg::solve::Inverse;
 use numpy::{IntoPyArray, PyArray2};
 use pyo3::exceptions::RuntimeError;
-use pyo3::prelude::{pymodinit, Py, PyErr, PyModule, PyResult, Python};
+use pyo3::prelude::{pymodule, Py, PyErr, PyModule, PyResult, Python};
 use std::fmt::Display;
 
 fn make_error<E: Display + Sized>(e: E) -> PyErr {
     PyErr::new::<RuntimeError, _>(format!("[rust_linalg] {}", e))
 }
 
-#[pymodinit]
+#[pymodule]
 fn rust_linalg(_py: Python, m: &PyModule) -> PyResult<()> {
     #[pyfn(m, "inv")]
     fn inv(py: Python, x: &PyArray2<f64>) -> PyResult<Py<PyArray2<f64>>> {

examples/simple-extension/Cargo.toml

@@ -12,5 +12,5 @@ numpy = { path = "../.." }
 ndarray = "0.12"
 
 [dependencies.pyo3]
-version = "0.5.3"
+version = "0.6.0"
 features = ["extension-module"]

examples/simple-extension/src/lib.rs

@@ -4,9 +4,9 @@ extern crate pyo3;
 
 use ndarray::{ArrayD, ArrayViewD, ArrayViewMutD};
 use numpy::{IntoPyArray, PyArrayDyn};
-use pyo3::prelude::{pymodinit, Py, PyModule, PyResult, Python};
+use pyo3::prelude::{pymodule, Py, PyModule, PyResult, Python};
 
-#[pymodinit]
+#[pymodule]
 fn rust_ext(_py: Python, m: &PyModule) -> PyResult<()> {
     // immutable example
     fn axpy(a: f64, x: ArrayViewD<f64>, y: ArrayViewD<f64>) -> ArrayD<f64> {

src/array.rs

@@ -2,8 +2,8 @@
 use ndarray::*;
 use npyffi::{self, npy_intp, NPY_ORDER, PY_ARRAY_API};
 use num_traits::AsPrimitive;
-use pyo3::{ffi, prelude::*, types::PyObjectRef};
-use pyo3::{PyDowncastError, PyObjectWithToken, ToPyPointer};
+use pyo3::{ffi, prelude::*, types::PyAny};
+use pyo3::{AsPyPointer, PyDowncastError, PyNativeType};
 use std::iter::ExactSizeIterator;
 use std::marker::PhantomData;
 use std::mem;
@@ -37,7 +37,6 @@ use types::{NpyDataType, TypeNum};
 /// So you can neither retrieve it nor deallocate it manually.
 ///
 /// # Reference
-///
 /// Like [`new`](#method.new), all constractor methods of `PyArray` returns `&PyArray`.
 ///
 /// This design follows
@@ -109,9 +108,9 @@ pyobject_native_type_convert!(
 
 pyobject_native_type_named!(PyArray<T, D>, T, D);
 
-impl<'a, T, D> ::std::convert::From<&'a PyArray<T, D>> for &'a PyObjectRef {
+impl<'a, T, D> ::std::convert::From<&'a PyArray<T, D>> for &'a PyAny {
     fn from(ob: &'a PyArray<T, D>) -> Self {
-        unsafe { &*(ob as *const PyArray<T, D> as *const PyObjectRef) }
+        unsafe { &*(ob as *const PyArray<T, D> as *const PyAny) }
     }
 }
 
@@ -120,12 +119,12 @@ impl<'a, T: TypeNum, D: Dimension> FromPyObject<'a> for &'a PyArray<T, D> {
     // 1. Checks if the object is PyArray
     // 2. Checks if the data type of the array is T
     // 3. Checks if the dimension is same as D
-    fn extract(ob: &'a PyObjectRef) -> PyResult<Self> {
+    fn extract(ob: &'a PyAny) -> PyResult<Self> {
         let array = unsafe {
             if npyffi::PyArray_Check(ob.as_ptr()) == 0 {
                 return Err(PyDowncastError.into());
             }
-            &*(ob as *const PyObjectRef as *const PyArray<T, D>)
+            &*(ob as *const PyAny as *const PyArray<T, D>)
         };
         array
             .type_check()

src/slice_box.rs

@@ -1,5 +1,5 @@
-use crate::types::TypeNum;
-use pyo3::{ffi, typeob, types::PyObjectRef, PyObjectAlloc, Python, ToPyPointer};
+use pyo3::class::methods::{PyMethodDefType, PyMethodsProtocol};
+use pyo3::{ffi, type_object, types::PyAny, AsPyPointer, PyObjectAlloc, Python};
 use std::os::raw::c_void;
 
 /// It's a memory store for IntoPyArray.
@@ -12,8 +12,7 @@ pub(crate) struct SliceBox<T> {
 
 impl<T> SliceBox<T> {
     pub(crate) unsafe fn new<'a>(box_: Box<[T]>) -> &'a Self {
-        <Self as typeob::PyTypeObject>::init_type();
-        let type_ob = <Self as typeob::PyTypeInfo>::type_object() as *mut _;
+        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;
@@ -26,9 +25,9 @@ impl<T> SliceBox<T> {
     }
 }
 
-impl<T> typeob::PyTypeInfo for SliceBox<T> {
+impl<T> type_object::PyTypeInfo for SliceBox<T> {
     type Type = ();
-    type BaseType = PyObjectRef;
+    type BaseType = PyAny;
     const NAME: &'static str = "SliceBox";
     const DESCRIPTION: &'static str = "Memory store for PyArray using rust's Box<[T]>.";
     const FLAGS: usize = 0;
@@ -41,38 +40,26 @@ impl<T> typeob::PyTypeInfo for SliceBox<T> {
     }
 }
 
-impl<T: TypeNum> typeob::PyTypeCreate for SliceBox<T> {
-    #[inline(always)]
-    fn init_type() {
-        static START: std::sync::Once = std::sync::ONCE_INIT;
-        START.call_once(|| {
-            let ty = unsafe { <Self as typeob::PyTypeInfo>::type_object() };
-            if (ty.tp_flags & ffi::Py_TPFLAGS_READY) == 0 {
-                let gil = Python::acquire_gil();
-                let py = gil.python();
-                let mod_name = format!("rust_numpy.{:?}", T::npy_data_type());
-                typeob::initialize_type::<Self>(py, Some(&mod_name))
-                    .map_err(|e| e.print(py))
-                    .expect("Failed to initialize SliceBox");
-            }
-        });
+impl<T> PyMethodsProtocol for SliceBox<T> {
+    fn py_methods() -> Vec<&'static PyMethodDefType> {
+        Vec::new()
     }
 }
 
-impl<T> ToPyPointer for SliceBox<T> {
+impl<T> AsPyPointer for SliceBox<T> {
     #[inline]
     fn as_ptr(&self) -> *mut ffi::PyObject {
         &self.ob_base as *const _ as *mut _
     }
 }
 
-impl<T> PyObjectAlloc<SliceBox<T>> for SliceBox<T> {
+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 typeob::PyTypeInfo>::BaseType::drop(py, obj);
+        <Self as type_object::PyTypeInfo>::BaseType::drop(py, obj);
     }
     unsafe fn dealloc(py: Python, obj: *mut ffi::PyObject) {
         Self::drop(py, obj);

tests/array.rs

@@ -4,7 +4,7 @@ extern crate pyo3;
 
 use ndarray::*;
 use numpy::*;
-use pyo3::{prelude::*, types::PyDict, types::PyList, ToPyPointer};
+use pyo3::{prelude::*, types::PyDict, types::PyList, AsPyPointer};
 
 #[test]
 fn new_c_order() {