add support for abi3t (#556)

* add support for abi3t

Author: Icxolu

.github/workflows/ci.yml

@@ -26,6 +26,7 @@ jobs:
   test:
     name: python${{ matrix.python-version }}-${{ matrix.platform.python-architecture }} ${{ matrix.platform.os }}
     runs-on: ${{ matrix.platform.os }}
+    continue-on-error: ${{ startsWith(matrix.python-version, '3.15') }} # remove once 3.15 releases
     needs: [lint, check-msrv, examples]
     strategy:
       fail-fast: ${{ !contains(github.event.pull_request.labels.*.name, 'CI-no-fail-fast') }}
@@ -40,6 +41,8 @@ jobs:
             "3.13",
             "3.14",
             "3.14t",
+            "3.15",
+            "3.15t",
             "pypy-3.11",
           ]
         platform:
@@ -78,31 +81,43 @@ jobs:
           # no 32 bit windows PyPy
           - python-version: pypy-3.11
             platform: { os: "windows-latest", python-architecture: "x86", rust-target: "i686-pc-windows-msvc" }
+          # free-threaded on 32bit only supported on 3.15+
+          - python-version: 3.14t
+            platform: { os: "windows-latest", python-architecture: "x86", rust-target: "i686-pc-windows-msvc" }
+
     steps:
       - uses: actions/checkout@v6
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
           architecture: ${{ matrix.platform.python-architecture }}
+          allow-prereleases: ${{ startsWith(matrix.python-version, '3.15') }} # remove once 3.15 releases
+      - name: Set up UV
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
           targets: ${{ matrix.platform.rust-target }}
       - name: Test
-        run: |
-          pip install "numpy" ml_dtypes
-          cargo test --all-features
         # Not on PyPy, because no embedding API
         if: ${{ !startsWith(matrix.python-version, 'pypy') }}
+        run: |
+          uv pip install "numpy" ml_dtypes
+          cargo test --all-features
+      - name: Test abi3t
+        if: ${{ endsWith(matrix.python-version, 't') }}
+        run: |
+          cargo test --all-features -F pyo3/abi3t
       - name: Test example
         run: |
-          pip install nox
-          nox -f examples/simple/noxfile.py
+          uvx nox -f examples/simple/noxfile.py
     env:
       CARGO_TERM_VERBOSE: true
       CARGO_BUILD_TARGET: ${{ matrix.platform.rust-target }}
       RUST_BACKTRACE: 1
+      UV_SYSTEM_PYTHON: true
+      NOX_DEFAULT_VENV_BACKEND: "uv"
 
   test-numpy1:
     name: python${{ matrix.python-version }}-${{ matrix.platform.python-architecture }} ${{ matrix.platform.os }} numpy1

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 - Unreleased
   - `PyReadonlyArray`/`PyReadwriteArray` extraction now returns a `PyErr` which reports the actual dtype/dimensionality mismatch instead of nonsensical `CastError` messages like “'ndarray' is not an instance of 'ndarray'” ([#562](https://github.com/PyO3/rust-numpy/pull/562))
+  - Add support for free-threaded stable abi (abi3t) from Python 3.15t+ ([#556](https://github.com/PyO3/rust-numpy/pull/556))
+  - fixed free-threaded builds for 32 bit platforms from Python 3.15+ ([#556](https://github.com/PyO3/rust-numpy/pull/556))
 
 - v0.29.0
   - Fix PyArray_DTypeMeta definition when Py_LIMITED_API is disabled ([#532](https://github.com/PyO3/rust-numpy/pull/532))

src/array.rs

@@ -28,7 +28,7 @@ use crate::error::{
     AsSliceError, BorrowError, DimensionalityError, FromVecError, IgnoreError, TypeError,
     DIMENSIONALITY_MISMATCH_ERR, MAX_DIMENSIONALITY_ERR,
 };
-use crate::npyffi::{self, npy_intp, NPY_ORDER, PY_ARRAY_API};
+use crate::npyffi::{self, _PyArray_GET_ITEM_DATA, npy_intp, NPY_ORDER, PY_ARRAY_API};
 use crate::slice_container::PySliceContainer;
 use crate::untyped_array::{PyUntypedArray, PyUntypedArrayMethods};
 
@@ -1481,7 +1481,7 @@ impl<'py, T, D> PyArrayMethods<'py, T, D> for Bound<'py, PyArray<T, D>> {
 
     #[inline(always)]
     fn data(&self) -> *mut T {
-        unsafe { (*self.as_array_ptr()).data.cast() }
+        unsafe { (*_PyArray_GET_ITEM_DATA(self.as_array_ptr())).data.cast() }
     }
 
     #[inline(always)]

src/borrow/mod.rs

@@ -182,7 +182,7 @@ use crate::convert::NpyIndex;
 use crate::dtype::Element;
 use crate::error::{AsSliceError, BorrowError};
 use crate::npyffi;
-use crate::npyffi::flags;
+use crate::npyffi::{_PyArray_GET_ITEM_DATA, flags};
 use crate::untyped_array::PyUntypedArrayMethods;
 
 use shared::{acquire, acquire_mut, release, release_mut};
@@ -538,7 +538,7 @@ where
         // SAFETY: consuming the only extant mutable reference guarantees we cannot invalidate an
         // existing reference, nor allow the caller to keep hold of one.
         unsafe {
-            (*self.as_array_ptr()).flags &= !flags::NPY_ARRAY_WRITEABLE;
+            (*_PyArray_GET_ITEM_DATA(self.as_array_ptr())).flags &= !flags::NPY_ARRAY_WRITEABLE;
         }
         self.into()
     }

src/borrow/shared.rs

@@ -15,7 +15,9 @@ use rustc_hash::FxHashMap;
 use crate::array::get_array_module;
 use crate::cold;
 use crate::error::BorrowError;
-use crate::npyffi::{PyArrayObject, PyArray_Check, PyDataType_ELSIZE, NPY_ARRAY_WRITEABLE};
+use crate::npyffi::{
+    _PyArray_GET_ITEM_DATA, PyArrayObject, PyArray_Check, PyDataType_ELSIZE, NPY_ARRAY_WRITEABLE,
+};
 
 /// Defines the shared C API used for borrow checking
 ///
@@ -57,7 +59,7 @@ unsafe extern "C" fn acquire_shared(flags: *mut c_void, array: *mut PyArrayObjec
 }
 
 unsafe extern "C" fn acquire_mut_shared(flags: *mut c_void, array: *mut PyArrayObject) -> c_int {
-    if (*array).flags & NPY_ARRAY_WRITEABLE == 0 {
+    if (*_PyArray_GET_ITEM_DATA(array)).flags & NPY_ARRAY_WRITEABLE == 0 {
         return -2;
     }
 
@@ -368,7 +370,7 @@ impl BorrowFlags {
 
 fn base_address<'py>(py: Python<'py>, mut array: *mut PyArrayObject) -> *mut c_void {
     loop {
-        let base = unsafe { (*array).base };
+        let base = unsafe { (*_PyArray_GET_ITEM_DATA(array)).base };
 
         if base.is_null() {
             return array as *mut c_void;
@@ -383,7 +385,7 @@ fn base_address<'py>(py: Python<'py>, mut array: *mut PyArrayObject) -> *mut c_v
 fn borrow_key<'py>(py: Python<'py>, array: *mut PyArrayObject) -> BorrowKey {
     let range = data_range(py, array);
 
-    let data_ptr = unsafe { (*array).data };
+    let data_ptr = unsafe { (*_PyArray_GET_ITEM_DATA(array)).data };
     let gcd_strides = gcd_strides(array);
 
     BorrowKey {
@@ -394,6 +396,7 @@ fn borrow_key<'py>(py: Python<'py>, array: *mut PyArrayObject) -> BorrowKey {
 }
 
 fn data_range<'py>(py: Python<'py>, array: *mut PyArrayObject) -> (*mut c_char, *mut c_char) {
+    let array = unsafe { _PyArray_GET_ITEM_DATA(array) };
     let nd = unsafe { (*array).nd } as usize;
     let data = unsafe { (*array).data };
 
@@ -430,6 +433,7 @@ fn data_range<'py>(py: Python<'py>, array: *mut PyArrayObject) -> (*mut c_char,
 }
 
 fn gcd_strides(array: *mut PyArrayObject) -> isize {
+    let array = unsafe { _PyArray_GET_ITEM_DATA(array) };
     let nd = unsafe { (*array).nd } as usize;
 
     if nd == 0 {
@@ -492,7 +496,7 @@ mod tests {
         Python::attach(|py| {
             let array = PyArray::<f64, _>::zeros(py, (1, 2, 3), false);
 
-            let base = unsafe { (*array.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(array.as_array_ptr().cast_const())).base };
             assert!(base.is_null());
 
             let base_address = base_address(py, array.as_array_ptr());
@@ -509,7 +513,7 @@ mod tests {
         Python::attach(|py| {
             let array = Array::<f64, _>::zeros((1, 2, 3)).into_pyarray(py);
 
-            let base = unsafe { (*array.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(array.as_array_ptr().cast_const())).base };
             assert!(!base.is_null());
 
             let base_address = base_address(py, array.as_array_ptr());
@@ -540,7 +544,7 @@ mod tests {
                 array.as_ptr().cast::<c_void>()
             );
 
-            let base = unsafe { (*view.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(view.as_array_ptr().cast_const())).base };
             assert_eq!(base as *mut c_void, array.as_ptr().cast::<c_void>());
 
             let base_address = base_address(py, view.as_array_ptr());
@@ -569,10 +573,10 @@ mod tests {
                 array.as_ptr().cast::<c_void>(),
             );
 
-            let base = unsafe { (*view.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(view.as_array_ptr().cast_const())).base };
             assert_eq!(base.cast::<c_void>(), array.as_ptr().cast::<c_void>());
 
-            let base = unsafe { (*array.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(array.as_array_ptr().cast_const())).base };
             assert!(!base.is_null());
 
             let base_address = base_address(py, view.as_array_ptr());
@@ -619,10 +623,10 @@ mod tests {
                 view1.as_ptr().cast::<c_void>()
             );
 
-            let base = unsafe { (*view2.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(view2.as_array_ptr().cast_const())).base };
             assert_eq!(base as *mut c_void, array.as_ptr().cast::<c_void>());
 
-            let base = unsafe { (*view1.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(view1.as_array_ptr().cast_const())).base };
             assert_eq!(base as *mut c_void, array.as_ptr().cast::<c_void>());
 
             let base_address = base_address(py, view2.as_array_ptr());
@@ -667,13 +671,13 @@ mod tests {
                 view1.as_ptr().cast::<c_void>(),
             );
 
-            let base = unsafe { (*view2.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(view2.as_array_ptr().cast_const())).base };
             assert_eq!(base.cast::<c_void>(), array.as_ptr().cast::<c_void>());
 
-            let base = unsafe { (*view1.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(view1.as_array_ptr().cast_const())).base };
             assert_eq!(base.cast::<c_void>(), array.as_ptr().cast::<c_void>());
 
-            let base = unsafe { (*array.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(array.as_array_ptr().cast_const())).base };
             assert!(!base.is_null());
 
             let base_address = base_address(py, view2.as_array_ptr());
@@ -706,7 +710,7 @@ mod tests {
                 array.as_ptr().cast::<c_void>()
             );
 
-            let base = unsafe { (*view.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(view.as_array_ptr().cast_const())).base };
             assert_eq!(base.cast::<c_void>(), array.as_ptr().cast::<c_void>());
 
             let base_address = base_address(py, view.as_array_ptr());
@@ -727,7 +731,7 @@ mod tests {
         Python::attach(|py| {
             let array = PyArray::<f64, _>::zeros(py, (1, 0, 3), false);
 
-            let base = unsafe { (*array.as_array_ptr()).base };
+            let base = unsafe { (*_PyArray_GET_ITEM_DATA(array.as_array_ptr().cast_const())).base };
             assert!(base.is_null());
 
             let base_address = base_address(py, array.as_array_ptr());

src/dtype.rs

@@ -17,9 +17,9 @@ use pyo3::{
 };
 
 use crate::npyffi::{
-    self, NpyTypes, PyArray_Descr, PyDataType_ALIGNMENT, PyDataType_ELSIZE, PyDataType_FIELDS,
-    PyDataType_FLAGS, PyDataType_NAMES, PyDataType_SUBARRAY, NPY_ALIGNED_STRUCT,
-    NPY_BYTEORDER_CHAR, NPY_ITEM_HASOBJECT, NPY_TYPES, PY_ARRAY_API,
+    self, _PyDataType_GET_ITEM_DATA, NpyTypes, PyArray_Descr, PyDataType_ALIGNMENT,
+    PyDataType_ELSIZE, PyDataType_FIELDS, PyDataType_FLAGS, PyDataType_NAMES, PyDataType_SUBARRAY,
+    NPY_ALIGNED_STRUCT, NPY_BYTEORDER_CHAR, NPY_ITEM_HASOBJECT, NPY_TYPES, PY_ARRAY_API,
 };
 
 pub use num_complex::{Complex32, Complex64};
@@ -159,7 +159,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 { &*_PyDataType_GET_ITEM_DATA(self.as_dtype_ptr()) }.type_num
     }
 
     /// Returns the element size of this type descriptor.
@@ -184,7 +184,9 @@ 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 { &*_PyDataType_GET_ITEM_DATA(self.as_dtype_ptr()) }
+            .byteorder
+            .max(0) as _
     }
 
     /// Returns a unique ASCII character for each of the 21 different built-in types.
@@ -195,7 +197,9 @@ 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 { &*_PyDataType_GET_ITEM_DATA(self.as_dtype_ptr()) }
+            .type_
+            .max(0) as _
     }
 
     /// Returns an ASCII character (one of `biufcmMOSUV`) identifying the general kind of data.
@@ -206,7 +210,9 @@ 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 { &*_PyDataType_GET_ITEM_DATA(self.as_dtype_ptr()) }
+            .kind
+            .max(0) as _
     }
 
     /// Returns bit-flags describing how this type descriptor is to be interpreted.
@@ -330,7 +336,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 { &*_PyDataType_GET_ITEM_DATA(self.as_dtype_ptr()) }.typeobj;
         unsafe { PyType::from_borrowed_type_ptr(self.py(), dtype_type_ptr) }
     }
 

src/lib.rs

@@ -181,3 +181,6 @@ macro_rules! pyarray {
         $crate::IntoPyArray::into_pyarray($crate::array![$($x,)*], $py)
     }};
 }
+
+#[cfg(all(not(Py_3_15), Py_GIL_DISABLED, target_pointer_width = "32"))]
+compile_error!("free-threaded Python on 32bit platforms is only supported from 3.15+");

src/npyffi/array.rs

@@ -301,6 +301,7 @@ impl PyArrayAPI {
     impl_api![189; PyArray_LexSort(sort_keys: *mut PyObject, axis: c_int) -> *mut PyObject];
     impl_api![190; PyArray_Round(a: *mut PyArrayObject, decimals: c_int, out: *mut PyArrayObject) -> *mut PyObject];
     impl_api![191; PyArray_EquivTypenums(typenum1: c_int, typenum2: c_int) -> c_uchar];
+    #[cfg(not(all(Py_LIMITED_API, Py_GIL_DISABLED)))]
     impl_api![192; PyArray_RegisterDataType(descr: *mut PyArray_DescrProto) -> c_int];
     impl_api![193; PyArray_RegisterCastFunc(descr: *mut PyArray_Descr, totype: c_int, castfunc: PyArray_VectorUnaryFunc) -> c_int];
     impl_api![194; PyArray_RegisterCanCast(descr: *mut PyArray_Descr, totype: c_int, scalar: NPY_SCALARKIND) -> c_int];
@@ -428,6 +429,22 @@ impl PyArrayAPI {
     // Min v2.0 impl_api![363; PyArray_CommonDType(dtype1: *mut PyArray_DTypeMeta, dtype2: *mut PyArray_DTypeMeta) -> PyArray_DTypeMeta];
     // Min v2.0 impl_api![364; PyArray_PromoteDTypeSequence(length: npy_intp, dtypes_in: *mut *mut PyArray_DTypeMeta) -> *mut PyArray_DTypeMeta];
     // Min v2.0 impl_api![365; _PyDataType_GetArrFuncs(descr: *const PyArray_Descr) -> *mut PyArray_ArrFuncs];
+    // Slot 366, 367, 368 are the abstract DTypes
+}
+
+// Min v2.5
+#[cfg(all(Py_LIMITED_API, Py_GIL_DISABLED))]
+impl PyArrayAPI {
+    impl_api![369; _PyArray_GET_ITEM_DATA(arr: *const PyArrayObject) -> *mut PyArrayObject_fields];
+    impl_api![370; _PyArrayIter_GET_ITEM_DATA(iter: *const PyArrayIterObject) -> *mut PyArrayIterObject_fields];
+    impl_api![371; pub(crate) _PyArray_LegacyDescr_GET_ITEM_DATA(dtype: *const _PyArray_LegacyDescr) -> *mut _PyArray_LegacyDescr_fields];
+    impl_api![372; _PyDataType_GET_ITEM_DATA(dtype: *const PyArray_Descr) -> *mut PyArray_Descr_fields];
+    impl_api![373; _PyArrayMultiIter_GET_ITEM_DATA(multi: *const PyArrayMultiIterObject) -> *mut PyArrayMultiIterObject_fields];
+    impl_api![374; _PyArrayNeighborhoodIter_GET_ITEM_DATA(iter: *const PyArrayNeighborhoodIterObject) -> *mut PyArrayNeighborhoodIterObject_fields];
+    impl_api![375; _PyDatetimeScalarObject_GetMetadata(obj: *mut PyObject) -> PyArray_DatetimeMetaData];
+    impl_api![376; _PyTimedeltaScalarObject_GetMetadata(obj: *mut PyObject) -> PyArray_DatetimeMetaData];
+    impl_api![377; _PyDatetimeScalarObject_GetValue(obj: *mut PyObject) -> npy_datetime];
+    impl_api![378; _PyTimedeltaScalarObject_GetValue(obj: *mut PyObject) -> npy_timedelta];
 }
 
 /// Checks that `op` is an instance of `PyArray` or not.

src/npyffi/mod.rs

@@ -58,12 +58,15 @@ pub fn is_numpy_2<'py>(py: Python<'py>) -> bool {
 macro_rules! impl_api {
     // API available on all versions
     [$offset: expr; $fname: ident ($($arg: ident: $t: ty),* $(,)?) $(-> $ret: ty)?] => {
+        impl_api![$offset; pub $fname($($arg : $t), *) $(-> $ret)*];
+    };
+    [$offset: expr; $vis:vis $fname: ident ($($arg: ident: $t: ty),* $(,)?) $(-> $ret: ty)?] => {
         #[allow(non_snake_case)]
-        pub unsafe fn $fname<'py>(&self, py: Python<'py>, $($arg : $t), *) $(-> $ret)* {
+        $vis unsafe fn $fname<'py>(&self, py: Python<'py>, $($arg : $t), *) $(-> $ret)* {
             let f: extern "C" fn ($($arg : $t), *) $(-> $ret)* = self.get(py, $offset).cast().read();
             f($($arg), *)
         }
-    };
+    }
 }
 
 // Define type objects associated with the NumPy API
@@ -82,6 +85,21 @@ macro_rules! impl_array_type {
     }
 }
 
+// Until `extern type` is stabilized, use the recommended approach to
+// model opaque types:
+// https://doc.rust-lang.org/nomicon/ffi.html#representing-opaque-structs
+#[cfg(all(Py_LIMITED_API, Py_GIL_DISABLED))]
+macro_rules! opaque_struct {
+    ($(#[$attrs:meta])* $pub:vis $name:ident) => {
+        $(#[$attrs])*
+        #[repr(C)]
+        $pub struct $name {
+            _data: (),
+            _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+        }
+    };
+}
+
 impl_array_type! {
     // Multiarray API
     // Slot 1 was never meaningfully used by NumPy