Check compatibility with chosen ABI/API versions

Author: mattiapenati

src/npyffi/array.rs

@@ -8,6 +8,7 @@ use std::{os::raw::*, ptr::NonNull};
 
 use libc::FILE;
 use pyo3::{
+    exceptions::PyRuntimeError,
     ffi::{self, PyObject, PyTypeObject},
     sync::PyOnceLock,
 };
@@ -85,7 +86,58 @@ impl PyArrayAPI {
     pub(super) unsafe fn get<'py>(&self, py: Python<'py>, offset: isize) -> NonNull<*const c_void> {
         let api = self
             .0
-            .get_or_try_init(py, || get_numpy_api(py, mod_name(py)?, CAPSULE_NAME))
+            .get_or_try_init(py, || -> PyResult<_> {
+                let api = get_numpy_api(py, mod_name(py)?, CAPSULE_NAME)?;
+
+                let module_version = {
+                    // unsigned int PyArray_GetNDArrayCVersion();
+                    let get_abi_version: extern "C" fn() -> c_uint =
+                        api.add(0).cast().read();
+                    get_abi_version()
+                };
+                if NPY_VERSION < module_version {
+                    return Err(PyRuntimeError::new_err(format!(
+                        "module compiled against ABI version 0x{:x} but this version of numpy is 0x{:x}",
+                        NPY_VERSION, module_version
+                    )));
+                }
+
+                let module_feature_version = unsafe {
+                    // unsigned int PyArray_GetNDArrayCFeatureVersion();
+                    let get_runtime_version: extern "C" fn() -> c_uint =
+                        api.add(211).cast().read();
+                    get_runtime_version()
+                };
+                if NPY_FEATURE_VERSION > module_feature_version {
+                    return Err(PyRuntimeError::new_err(format!(
+                        "module was compiled against NumPy C-API version 0x{:x} (NumPy {}) but the running NumPy has C-API version 0x{:x}",
+                        NPY_FEATURE_VERSION, NPY_FEATURE_VERSION_STRING, module_feature_version
+                    )));
+                }
+
+                let endianess = unsafe {
+                    // int PyArray_GetEndianness();
+                    let get_endianess: extern "C" fn() -> c_int =
+                        api.add(210).cast().read();
+                    get_endianess()
+                };
+
+                #[cfg(target_endian = "big")]
+                if endianess != NPY_CPU_BIG {
+                    return Err(PyRuntimeError::new_err(
+                        "module compiled as big endian, but detected different endianess at runtime",
+                    ));
+                }
+
+                #[cfg(target_endian = "little")]
+                if endianess != NPY_CPU_LITTLE {
+                    return Err(PyRuntimeError::new_err(
+                        "module compiled as little endian, but detected different endianess at runtime",
+                    ));
+                }
+
+                Ok(api)
+            })
             .expect("Failed to access NumPy array API capsule");
 
         api.offset(offset)

src/npyffi/mod.rs

@@ -20,8 +20,6 @@ use pyo3::{
     PyResult, Python,
 };
 
-pub const API_VERSION_2_0: c_uint = 0x00000012;
-
 static API_VERSION: PyOnceLock<c_uint> = PyOnceLock::new();
 
 fn get_numpy_api<'py>(
@@ -46,7 +44,7 @@ pub fn is_numpy_2<'py>(py: Python<'py>) -> bool {
     let api_version = *API_VERSION.get_or_init(py, || unsafe {
         PY_ARRAY_API.PyArray_GetNDArrayCFeatureVersion(py)
     });
-    api_version >= API_VERSION_2_0
+    api_version >= NPY_2_0_API_VERSION
 }
 
 // Implements wrappers for NumPy's Array and UFunc API
@@ -129,12 +127,16 @@ impl_array_type! {
 
 pub mod array;
 pub mod flags;
+mod npy_common;
+mod numpyconfig;
 pub mod objects;
 pub mod types;
 pub mod ufunc;
 
 pub use self::array::*;
 pub use self::flags::*;
+pub use self::npy_common::*;
+pub use self::numpyconfig::*;
 pub use self::objects::*;
 pub use self::types::*;
 pub use self::ufunc::*;

src/npyffi/npy_common.rs

@@ -0,0 +1,8 @@
+use std::ffi::c_int;
+
+/// Unknown CPU endianness.
+pub const NPY_CPU_UNKNOWN_ENDIAN: c_int = 0;
+/// CPU is little-endian.
+pub const NPY_CPU_LITTLE: c_int = 1;
+/// CPU is big-endian.
+pub const NPY_CPU_BIG: c_int = 2;

src/npyffi/numpyconfig.rs

@@ -0,0 +1,18 @@
+// This file matches the numpyconfig.h header.
+
+use std::ffi::c_uint;
+
+/// The current target ABI version
+const NPY_ABI_VERSION: c_uint = 0x02000000;
+
+/// The current target API version (v1.15)
+const NPY_API_VERSION: c_uint = 0x0000000c;
+
+pub(super) const NPY_2_0_API_VERSION: c_uint = 0x00000012;
+
+/// The current version of the `ndarray` object (ABI version).
+pub const NPY_VERSION: c_uint = NPY_ABI_VERSION;
+/// The current version of C API.
+pub const NPY_FEATURE_VERSION: c_uint = NPY_API_VERSION;
+/// The string representation of current version C API.
+pub const NPY_FEATURE_VERSION_STRING: &str = "1.15";