initial migration to pyo3 0.23

Author: Icxolu

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "numpy"
-version = "0.22.1"
+version = "0.23.0-dev"
 authors = [
     "The rust-numpy Project Developers",
     "PyO3 Project and Contributors <https://github.com/PyO3>"
@@ -22,11 +22,11 @@ num-complex = ">= 0.2, < 0.5"
 num-integer = "0.1"
 num-traits = "0.2"
 ndarray = ">= 0.15, < 0.17"
-pyo3 = { version = "0.22.0", default-features = false, features = ["macros"] }
+pyo3 = { version = "0.23.0-dev", default-features = false, features = ["macros"] }
 rustc-hash = "1.1"
 
 [dev-dependencies]
-pyo3 = { version = "0.22.0", default-features = false, features = ["auto-initialize"] }
+pyo3 = { version = "0.23.0-dev", default-features = false, features = ["auto-initialize"] }
 nalgebra = { version = ">=0.30, <0.34", default-features = false, features = ["std"] }
 
 [package.metadata.docs.rs]

src/array.rs

@@ -5,7 +5,6 @@
 use std::{
     marker::PhantomData,
     mem,
-    ops::Deref,
     os::raw::{c_int, c_void},
     ptr, slice,
 };
@@ -17,10 +16,9 @@ use ndarray::{
 };
 use num_traits::AsPrimitive;
 use pyo3::{
-    ffi, pyobject_native_type_base,
+    ffi,
     types::{DerefToPyAny, PyAnyMethods, PyModule},
-    AsPyPointer, Bound, DowncastError, IntoPy, Py, PyAny, PyErr, PyObject, PyResult, PyTypeInfo,
-    Python,
+    Bound, DowncastError, Py, PyAny, PyErr, PyObject, PyResult, PyTypeInfo, Python,
 };
 
 use crate::borrow::{PyReadonlyArray, PyReadwriteArray};
@@ -133,63 +131,11 @@ unsafe impl<T: Element, D: Dimension> PyTypeInfo for PyArray<T, D> {
         unsafe { npyffi::PY_ARRAY_API.get_type_object(py, npyffi::NpyTypes::PyArray_Type) }
     }
 
-    fn is_type_of_bound(ob: &Bound<'_, PyAny>) -> bool {
+    fn is_type_of(ob: &Bound<'_, PyAny>) -> bool {
         Self::extract::<IgnoreError>(ob).is_ok()
     }
 }
 
-pyobject_native_type_base!(PyArray<T, D>; T; D);
-
-impl<T, D> AsRef<PyAny> for PyArray<T, D> {
-    #[inline]
-    fn as_ref(&self) -> &PyAny {
-        &self.0
-    }
-}
-
-impl<T, D> Deref for PyArray<T, D> {
-    type Target = PyUntypedArray;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        self.as_untyped()
-    }
-}
-
-unsafe impl<T, D> AsPyPointer for PyArray<T, D> {
-    #[inline]
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        self.0.as_ptr()
-    }
-}
-
-impl<T, D> IntoPy<Py<PyArray<T, D>>> for &'_ PyArray<T, D> {
-    #[inline]
-    fn into_py<'py>(self, py: Python<'py>) -> Py<PyArray<T, D>> {
-        unsafe { Py::from_borrowed_ptr(py, self.as_ptr()) }
-    }
-}
-
-impl<'a, T, D> 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 PyAny) }
-    }
-}
-
-impl<T, D> IntoPy<PyObject> for PyArray<T, D> {
-    fn into_py<'py>(self, py: Python<'py>) -> PyObject {
-        unsafe { PyObject::from_borrowed_ptr(py, self.as_ptr()) }
-    }
-}
-
-impl<T, D> PyArray<T, D> {
-    /// Access an untyped representation of this array.
-    #[inline(always)]
-    pub fn as_untyped(&self) -> &PyUntypedArray {
-        unsafe { &*(self as *const Self as *const PyUntypedArray) }
-    }
-}
-
 impl<T: Element, D: Dimension> PyArray<T, D> {
     fn extract<'a, 'py, E>(ob: &'a Bound<'py, PyAny>) -> Result<&'a Bound<'py, Self>, E>
     where

src/dtype.rs

@@ -10,7 +10,7 @@ use pyo3::sync::GILOnceCell;
 use pyo3::{
     exceptions::{PyIndexError, PyValueError},
     ffi::{self, PyTuple_Size},
-    pyobject_native_type_extract, pyobject_native_type_named,
+    pyobject_native_type_named,
     types::{PyAnyMethods, PyDict, PyDictMethods, PyTuple, PyType},
     Borrowed, Bound, Py, PyAny, PyObject, PyResult, PyTypeInfo, Python, ToPyObject,
 };
@@ -60,8 +60,6 @@ unsafe impl PyTypeInfo for PyArrayDescr {
     }
 }
 
-pyobject_native_type_extract!(PyArrayDescr);
-
 /// Returns the type descriptor ("dtype") for a registered type.
 pub fn dtype_bound<'py, T: Element>(py: Python<'py>) -> Bound<'py, PyArrayDescr> {
     T::get_dtype_bound(py)
@@ -148,7 +146,7 @@ pub trait PyArrayDescrMethods<'py>: Sealed {
     /// [enumerated-types]: https://numpy.org/doc/stable/reference/c-api/dtype.html#enumerated-types
     /// [dtype-num]: https://numpy.org/doc/stable/reference/generated/numpy.dtype.num.html
     fn num(&self) -> c_int {
-        unsafe { *self.as_dtype_ptr() }.type_num
+        unsafe { &*self.as_dtype_ptr() }.type_num
     }
 
     /// Returns the element size of this type descriptor.
@@ -173,7 +171,7 @@ pub trait PyArrayDescrMethods<'py>: Sealed {
     ///
     /// [dtype-byteorder]: https://numpy.org/doc/stable/reference/generated/numpy.dtype.byteorder.html
     fn byteorder(&self) -> u8 {
-        unsafe { *self.as_dtype_ptr() }.byteorder.max(0) as _
+        unsafe { &*self.as_dtype_ptr() }.byteorder.max(0) as _
     }
 
     /// Returns a unique ASCII character for each of the 21 different built-in types.
@@ -184,7 +182,7 @@ pub trait PyArrayDescrMethods<'py>: Sealed {
     ///
     /// [dtype-char]: https://numpy.org/doc/stable/reference/generated/numpy.dtype.char.html
     fn char(&self) -> u8 {
-        unsafe { *self.as_dtype_ptr() }.type_.max(0) as _
+        unsafe { &*self.as_dtype_ptr() }.type_.max(0) as _
     }
 
     /// Returns an ASCII character (one of `biufcmMOSUV`) identifying the general kind of data.
@@ -195,7 +193,7 @@ pub trait PyArrayDescrMethods<'py>: Sealed {
     ///
     /// [dtype-kind]: https://numpy.org/doc/stable/reference/generated/numpy.dtype.kind.html
     fn kind(&self) -> u8 {
-        unsafe { *self.as_dtype_ptr() }.kind.max(0) as _
+        unsafe { &*self.as_dtype_ptr() }.kind.max(0) as _
     }
 
     /// Returns bit-flags describing how this type descriptor is to be interpreted.
@@ -319,7 +317,7 @@ impl<'py> PyArrayDescrMethods<'py> for Bound<'py, PyArrayDescr> {
     }
 
     fn typeobj(&self) -> Bound<'py, PyType> {
-        let dtype_type_ptr = unsafe { *self.as_dtype_ptr() }.typeobj;
+        let dtype_type_ptr = unsafe { &*self.as_dtype_ptr() }.typeobj;
         unsafe { PyType::from_borrowed_type_ptr(self.py(), dtype_type_ptr) }
     }
 
@@ -725,7 +723,7 @@ mod tests {
             assert!(!dt.has_subarray());
             assert!(dt.base().is_equiv_to(&dt));
             assert_eq!(dt.ndim(), 0);
-            assert_eq!(dt.shape(), vec![]);
+            assert_eq!(dt.shape(), Vec::<usize>::new());
         });
     }
 
@@ -801,7 +799,7 @@ mod tests {
             assert!(dt.is_aligned_struct());
             assert!(!dt.has_subarray());
             assert_eq!(dt.ndim(), 0);
-            assert_eq!(dt.shape(), vec![]);
+            assert_eq!(dt.shape(), Vec::<usize>::new());
             assert!(dt.base().is_equiv_to(&dt));
             let x = dt.get_field("x").unwrap();
             assert!(x.0.is_equiv_to(&dtype_bound::<u8>(py)));

src/npyffi/objects.rs

@@ -11,7 +11,6 @@ use super::types::*;
 use crate::npyffi::*;
 
 #[repr(C)]
-#[derive(Copy, Clone)]
 pub struct PyArrayObject {
     pub ob_base: PyObject,
     pub data: *mut c_char,
@@ -25,7 +24,6 @@ pub struct PyArrayObject {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone)]
 pub struct PyArray_Descr {
     pub ob_base: PyObject,
     pub typeobj: *mut PyTypeObject,
@@ -37,7 +35,6 @@ pub struct PyArray_Descr {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone)]
 pub struct PyArray_DescrProto {
     pub ob_base: PyObject,
     pub typeobj: *mut PyTypeObject,
@@ -58,7 +55,6 @@ pub struct PyArray_DescrProto {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone)]
 pub struct _PyArray_DescrNumPy2 {
     pub ob_base: PyObject,
     pub typeobj: *mut PyTypeObject,
@@ -76,7 +72,6 @@ pub struct _PyArray_DescrNumPy2 {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone)]
 struct _PyArray_LegacyDescr {
     pub ob_base: PyObject,
     pub typeobj: *mut PyTypeObject,
@@ -310,7 +305,6 @@ pub type PyArray_FastTakeFunc = Option<
 >;
 
 #[repr(C)]
-#[derive(Clone, Copy)]
 pub struct PyArrayFlagsObject {
     pub ob_base: PyObject,
     pub arr: *mut PyObject,
@@ -325,7 +319,6 @@ pub struct PyArray_Dims {
 }
 
 #[repr(C)]
-#[derive(Clone, Copy)]
 pub struct PyArray_Chunk {
     pub ob_base: PyObject,
     pub base: *mut PyObject,
@@ -349,7 +342,6 @@ pub struct PyArrayInterface {
 }
 
 #[repr(C)]
-#[derive(Clone, Copy)]
 pub struct PyUFuncObject {
     pub ob_base: PyObject,
     pub nin: c_int,
@@ -428,7 +420,6 @@ pub type PyUFunc_MaskedInnerLoopSelectionFunc = Option<
 pub struct NpyIter([u8; 0]);
 
 #[repr(C)]
-#[derive(Clone, Copy)]
 pub struct PyArrayIterObject {
     pub ob_base: PyObject,
     pub nd_m1: c_int,
@@ -449,7 +440,6 @@ pub struct PyArrayIterObject {
 }
 
 #[repr(C)]
-#[derive(Clone, Copy)]
 pub struct PyArrayMultiIterObject {
     pub ob_base: PyObject,
     pub numiter: c_int,
@@ -461,7 +451,6 @@ pub struct PyArrayMultiIterObject {
 }
 
 #[repr(C)]
-#[derive(Clone, Copy)]
 pub struct PyArrayNeighborhoodIterObject {
     pub ob_base: PyObject,
     pub nd_m1: c_int,
@@ -487,7 +476,6 @@ pub struct PyArrayNeighborhoodIterObject {
 }
 
 #[repr(C)]
-#[derive(Clone, Copy)]
 pub struct PyArrayMapIterObject {
     pub ob_base: PyObject,
     pub numiter: c_int,
@@ -571,7 +559,6 @@ pub struct npy_static_string {
 }
 
 #[repr(C)]
-#[derive(Clone, Copy)]
 pub struct PyArray_StringDTypeObject {
     pub base: PyArray_Descr,
     pub na_object: *mut PyObject,

src/untyped_array.rs

@@ -4,8 +4,7 @@
 use std::slice;
 
 use pyo3::{
-    ffi, pyobject_native_type_extract, pyobject_native_type_named, types::PyAnyMethods,
-    AsPyPointer, Bound, IntoPy, PyAny, PyObject, PyTypeInfo, Python,
+    ffi, pyobject_native_type_named, types::PyAnyMethods, Bound, PyAny, PyTypeInfo, Python,
 };
 
 use crate::array::{PyArray, PyArrayMethods};
@@ -70,21 +69,13 @@ unsafe impl PyTypeInfo for PyUntypedArray {
         unsafe { npyffi::PY_ARRAY_API.get_type_object(py, npyffi::NpyTypes::PyArray_Type) }
     }
 
-    fn is_type_of_bound(ob: &Bound<'_, PyAny>) -> bool {
+    fn is_type_of(ob: &Bound<'_, PyAny>) -> bool {
         unsafe { npyffi::PyArray_Check(ob.py(), ob.as_ptr()) != 0 }
     }
 }
 
 pyobject_native_type_named!(PyUntypedArray);
 
-impl IntoPy<PyObject> for PyUntypedArray {
-    fn into_py<'py>(self, py: Python<'py>) -> PyObject {
-        unsafe { PyObject::from_borrowed_ptr(py, self.as_ptr()) }
-    }
-}
-
-pyobject_native_type_extract!(PyUntypedArray);
-
 /// Implementation of functionality for [`PyUntypedArray`].
 #[doc(alias = "PyUntypedArray")]
 pub trait PyUntypedArrayMethods<'py>: Sealed {

tests/array.rs

@@ -91,8 +91,8 @@ fn rank_zero_array_has_invalid_strides_dimensions() {
         let arr = PyArray::<f64, _>::zeros_bound(py, (), false);
 
         assert_eq!(arr.ndim(), 0);
-        assert_eq!(arr.strides(), &[]);
-        assert_eq!(arr.shape(), &[]);
+        assert_eq!(arr.strides(), &[] as &[isize]);
+        assert_eq!(arr.shape(), &[] as &[usize]);
 
         assert_eq!(arr.len(), 1);
         assert!(!arr.is_empty());
@@ -609,7 +609,14 @@ fn unicode_strings_with_explicit_dtype_works() {
             assert_eq!(array[1].0, [b'b' as _, b'a' as _, b'r' as _, 0, 0, 0]);
             assert_eq!(
                 array[2].0,
-                [b'f' as _, b'o' as _, b'o' as _, b'b' as _, b'a' as _, b'r' as _]
+                [
+                    b'f' as u32,
+                    b'o' as _,
+                    b'o' as _,
+                    b'b' as _,
+                    b'a' as _,
+                    b'r' as _
+                ]
             );
         }