Update with PyO3 0.11.0

Author: kngwyu

Cargo.toml

@@ -15,7 +15,8 @@ libc = "0.2"
 num-complex = "0.2"
 num-traits = "0.2"
 ndarray = ">=0.13"
-pyo3 = "0.10.1"
+# pyo3 = "0.10.1"
+pyo3 = { git = "https://github.com/PyO3/pyo3.git"}
 
 [features]
 # In default setting, python version is automatically detected

src/array.rs

@@ -208,7 +208,7 @@ impl<T, D> PyArray<T, D> {
     /// # }
     /// ```
     pub fn to_owned(&self) -> Py<Self> {
-        unsafe { Py::from_borrowed_ptr(self.as_ptr()) }
+        unsafe { Py::from_borrowed_ptr(self.py(), self.as_ptr()) }
     }
 
     /// Constructs `PyArray` from raw python object without incrementing reference counts.

src/lib.rs

@@ -28,8 +28,6 @@
 //!     );
 //! }
 //! ```
-#![feature(specialization)]
-#![deny(rust_2018_idioms)]
 
 #[macro_use]
 extern crate cfg_if;

src/npyffi/array.rs

@@ -2,7 +2,7 @@
 use libc::FILE;
 use pyo3::ffi::{self, PyObject, PyTypeObject};
 use std::os::raw::*;
-use std::{cell::Cell, ptr, sync::Once};
+use std::{cell::Cell, ptr};
 
 use crate::npyffi::*;
 
@@ -33,21 +33,20 @@ pub static PY_ARRAY_API: PyArrayAPI = PyArrayAPI::new();
 
 /// See [PY_ARRAY_API] for more.
 pub struct PyArrayAPI {
-    once: Once,
     api: Cell<*const *const c_void>,
 }
 
 impl PyArrayAPI {
     const fn new() -> Self {
         Self {
-            once: Once::new(),
             api: Cell::new(ptr::null_mut()),
         }
     }
     fn get(&self, offset: isize) -> *const *const c_void {
         if self.api.get().is_null() {
-            let api = get_numpy_api(MOD_NAME, CAPSULE_NAME);
-            self.once.call_once(|| self.api.set(api));
+            let ensure_gil = pyo3::internal_utils::ensure_gil();
+            let api = get_numpy_api(unsafe { ensure_gil.python() }, MOD_NAME, CAPSULE_NAME);
+            self.api.set(api);
         }
         unsafe { self.api.get().offset(offset) }
     }

src/npyffi/mod.rs

@@ -3,21 +3,15 @@
 //! https://numpy.org/doc/stable/reference/c-api
 #![allow(non_camel_case_types)]
 
-use pyo3::ffi;
+use pyo3::{ffi, Python};
 use std::ffi::CString;
 use std::os::raw::c_void;
 use std::ptr::null_mut;
 
-fn get_numpy_api(module: &str, capsule: &str) -> *const *const c_void {
+fn get_numpy_api(_py: Python, module: &str, capsule: &str) -> *const *const c_void {
     let module = CString::new(module).unwrap();
     let capsule = CString::new(capsule).unwrap();
     unsafe {
-        assert_ne!(
-            ffi::Py_IsInitialized(),
-            0,
-            r"Numpy API is called before initializing Python!
-Please make sure that you get gil, by `let gil = Python::acquire_gil();`"
-        );
         let numpy = ffi::PyImport_ImportModule(module.as_ptr());
         assert!(!numpy.is_null(), "Failed to import numpy module");
         let capsule = ffi::PyObject_GetAttrString(numpy as _, capsule.as_ptr());

src/npyffi/ufunc.rs

@@ -1,7 +1,7 @@
 //! Low-Level binding for [UFunc API](https://numpy.org/doc/stable/reference/c-api/ufunc.html)
 
 use std::os::raw::*;
-use std::{cell::Cell, ptr, sync::Once};
+use std::{cell::Cell, ptr};
 
 use pyo3::ffi::PyObject;
 
@@ -17,21 +17,20 @@ const CAPSULE_NAME: &str = "_UFUNC_API";
 pub static PY_UFUNC_API: PyUFuncAPI = PyUFuncAPI::new();
 
 pub struct PyUFuncAPI {
-    once: Once,
     api: Cell<*const *const c_void>,
 }
 
 impl PyUFuncAPI {
     const fn new() -> Self {
         Self {
-            once: Once::new(),
             api: Cell::new(ptr::null_mut()),
         }
     }
     fn get(&self, offset: isize) -> *const *const c_void {
         if self.api.get().is_null() {
-            let api = get_numpy_api(MOD_NAME, CAPSULE_NAME);
-            self.once.call_once(|| self.api.set(api));
+            let ensure_gil = pyo3::internal_utils::ensure_gil();
+            let api = get_numpy_api(unsafe { ensure_gil.python() }, MOD_NAME, CAPSULE_NAME);
+            self.api.set(api);
         }
         unsafe { self.api.get().offset(offset) }
     }

src/slice_box.rs

@@ -1,4 +1,4 @@
-use pyo3::class::methods::PyMethodsImpl;
+use pyo3::class::{methods::PyMethods, proto_methods::PyProtoMethods};
 use pyo3::pyclass::{PyClass, PyClassAlloc};
 use pyo3::pyclass_slots::PyClassDummySlot;
 use pyo3::{ffi, type_object, types::PyAny, PyCell, PyClassInitializer};
@@ -42,11 +42,13 @@ unsafe impl<T> type_object::PyTypeInfo for SliceBox<T> {
     const FLAGS: usize = 0;
 
     #[inline]
-    fn type_object() -> &'static ffi::PyTypeObject {
+    fn type_object_raw(py: pyo3::Python) -> *mut ffi::PyTypeObject {
         use pyo3::type_object::LazyStaticType;
         static TYPE_OBJECT: LazyStaticType = LazyStaticType::new();
-        TYPE_OBJECT.get_or_init::<Self>()
+        TYPE_OBJECT.get_or_init::<Self>(py)
     }
 }
 
-impl<T> PyMethodsImpl for SliceBox<T> {}
+impl<T> PyMethods for SliceBox<T> {}
+impl<T> PyProtoMethods for SliceBox<T> {}
+unsafe impl<T> Send for SliceBox<T> {}