Remove the numpy < 2 compatibility header

pytensor/npy_2_compat.py

-from textwrap import dedent
-
 import numpy as np
 
 
@@ -22,227 +20,3 @@ def old_np_unique(
         outs[inv_idx] = outs[inv_idx].reshape(inv_shape)
 
     return tuple(outs)
-
-
-# compatibility header for C code
-def npy_2_compat_header() -> str:
-    """Compatibility header that Numpy suggests is vendored with code that uses Numpy < 2.0 and Numpy 2.x"""
-    return dedent("""
-    #ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_2_COMPAT_H_
-    #define NUMPY_CORE_INCLUDE_NUMPY_NPY_2_COMPAT_H_
-
-
-    /*
-     * This header is meant to be included by downstream directly for 1.x compat.
-     * In that case we need to ensure that users first included the full headers
-     * and not just `ndarraytypes.h`.
-     */
-
-    #ifndef NPY_FEATURE_VERSION
-      #error "The NumPy 2 compat header requires `import_array()` for which "  \\
-             "the `ndarraytypes.h` header include is not sufficient.  Please "  \\
-             "include it after `numpy/ndarrayobject.h` or similar."  \\
-             "" \\
-             "To simplify inclusion, you may use `PyArray_ImportNumPy()` " \\
-             "which is defined in the compat header and is lightweight (can be)."
-    #endif
-
-    #if NPY_ABI_VERSION < 0x02000000
-      /*
-       * Define 2.0 feature version as it is needed below to decide whether we
-       * compile for both 1.x and 2.x (defining it gaurantees 1.x only).
-       */
-      #define NPY_2_0_API_VERSION 0x00000012
-      /*
-       * If we are compiling with NumPy 1.x, PyArray_RUNTIME_VERSION so we
-       * pretend the `PyArray_RUNTIME_VERSION` is `NPY_FEATURE_VERSION`.
-       * This allows downstream to use `PyArray_RUNTIME_VERSION` if they need to.
-       */
-      #define PyArray_RUNTIME_VERSION NPY_FEATURE_VERSION
-      /* Compiling on NumPy 1.x where these are the same: */
-      #define PyArray_DescrProto PyArray_Descr
-    #endif
-
-
-    /*
-     * Define a better way to call `_import_array()` to simplify backporting as
-     * we now require imports more often (necessary to make ABI flexible).
-     */
-    #ifdef import_array1
-
-    static inline int
-    PyArray_ImportNumPyAPI()
-    {
-        if (NPY_UNLIKELY(PyArray_API == NULL)) {
-            import_array1(-1);
-        }
-        return 0;
-    }
-
-    #endif  /* import_array1 */
-
-
-    /*
-     * NPY_DEFAULT_INT
-     *
-     * The default integer has changed, `NPY_DEFAULT_INT` is available at runtime
-     * for use as type number, e.g. `PyArray_DescrFromType(NPY_DEFAULT_INT)`.
-     *
-     * NPY_RAVEL_AXIS
-     *
-     * This was introduced in NumPy 2.0 to allow indicating that an axis should be
-     * raveled in an operation. Before NumPy 2.0, NPY_MAXDIMS was used for this purpose.
-     *
-     * NPY_MAXDIMS
-     *
-     * A constant indicating the maximum number dimensions allowed when creating
-     * an ndarray.
-     *
-     * NPY_NTYPES_LEGACY
-     *
-     * The number of built-in NumPy dtypes.
-     */
-    #if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION
-        #define NPY_DEFAULT_INT NPY_INTP
-        #define NPY_RAVEL_AXIS NPY_MIN_INT
-        #define NPY_MAXARGS 64
-
-    #elif NPY_ABI_VERSION < 0x02000000
-        #define NPY_DEFAULT_INT NPY_LONG
-        #define NPY_RAVEL_AXIS 32
-        #define NPY_MAXARGS 32
-
-        /* Aliases of 2.x names to 1.x only equivalent names */
-        #define NPY_NTYPES NPY_NTYPES_LEGACY
-        #define PyArray_DescrProto PyArray_Descr
-        #define _PyArray_LegacyDescr PyArray_Descr
-        /* NumPy 2 definition always works, but add it for 1.x only */
-        #define PyDataType_ISLEGACY(dtype) (1)
-    #else
-        #define NPY_DEFAULT_INT  \\
-            (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION ? NPY_INTP : NPY_LONG)
-        #define NPY_RAVEL_AXIS  \\
-            (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION ? -1 : 32)
-        #define NPY_MAXARGS  \\
-            (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION ? 64 : 32)
-    #endif
-
-
-    /*
-     * Access inline functions for descriptor fields.  Except for the first
-     * few fields, these needed to be moved (elsize, alignment) for
-     * additional space.  Or they are descriptor specific and are not generally
-     * available anymore (metadata, c_metadata, subarray, names, fields).
-     *
-     * Most of these are defined via the `DESCR_ACCESSOR` macro helper.
-     */
-    #if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION || NPY_ABI_VERSION < 0x02000000
-        /* Compiling for 1.x or 2.x only, direct field access is OK: */
-
-        static inline void
-        PyDataType_SET_ELSIZE(PyArray_Descr *dtype, npy_intp size)
-        {
-            dtype->elsize = size;
-        }
-
-        static inline npy_uint64
-        PyDataType_FLAGS(const PyArray_Descr *dtype)
-        {
-        #if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION
-            return dtype->flags;
-        #else
-            return (unsigned char)dtype->flags;  /* Need unsigned cast on 1.x */
-        #endif
-        }
-
-        #define DESCR_ACCESSOR(FIELD, field, type, legacy_only)    \\
-            static inline type                                     \\
-            PyDataType_##FIELD(const PyArray_Descr *dtype) {       \\
-                if (legacy_only && !PyDataType_ISLEGACY(dtype)) {  \\
-                    return (type)0;                                \\
-                }                                                  \\
-                return ((_PyArray_LegacyDescr *)dtype)->field;     \\
-            }
-    #else  /* compiling for both 1.x and 2.x */
-
-        static inline void
-        PyDataType_SET_ELSIZE(PyArray_Descr *dtype, npy_intp size)
-        {
-            if (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION) {
-                ((_PyArray_DescrNumPy2 *)dtype)->elsize = size;
-            }
-            else {
-                ((PyArray_DescrProto *)dtype)->elsize = (int)size;
-            }
-        }
-
-        static inline npy_uint64
-        PyDataType_FLAGS(const PyArray_Descr *dtype)
-        {
-            if (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION) {
-                return ((_PyArray_DescrNumPy2 *)dtype)->flags;
-            }
-            else {
-                return (unsigned char)((PyArray_DescrProto *)dtype)->flags;
-            }
-        }
-
-        /* Cast to LegacyDescr always fine but needed when `legacy_only` */
-        #define DESCR_ACCESSOR(FIELD, field, type, legacy_only)        \\
-            static inline type                                         \\
-            PyDataType_##FIELD(const PyArray_Descr *dtype) {           \\
-                if (legacy_only && !PyDataType_ISLEGACY(dtype)) {      \\
-                    return (type)0;                                    \\
-                }                                                      \\
-                if (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION) {  \\
-                    return ((_PyArray_LegacyDescr *)dtype)->field;     \\
-                }                                                      \\
-                else {                                                 \\
-                    return ((PyArray_DescrProto *)dtype)->field;       \\
-                }                                                      \\
-            }
-    #endif
-
-    DESCR_ACCESSOR(ELSIZE, elsize, npy_intp, 0)
-    DESCR_ACCESSOR(ALIGNMENT, alignment, npy_intp, 0)
-    DESCR_ACCESSOR(METADATA, metadata, PyObject *, 1)
-    DESCR_ACCESSOR(SUBARRAY, subarray, PyArray_ArrayDescr *, 1)
-    DESCR_ACCESSOR(NAMES, names, PyObject *, 1)
-    DESCR_ACCESSOR(FIELDS, fields, PyObject *, 1)
-    DESCR_ACCESSOR(C_METADATA, c_metadata, NpyAuxData *, 1)
-
-    #undef DESCR_ACCESSOR
-
-
-    #if !(defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD)
-    #if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION
-        static inline PyArray_ArrFuncs *
-        PyDataType_GetArrFuncs(const PyArray_Descr *descr)
-        {
-            return _PyDataType_GetArrFuncs(descr);
-        }
-    #elif NPY_ABI_VERSION < 0x02000000
-        static inline PyArray_ArrFuncs *
-        PyDataType_GetArrFuncs(const PyArray_Descr *descr)
-        {
-            return descr->f;
-        }
-    #else
-        static inline PyArray_ArrFuncs *
-        PyDataType_GetArrFuncs(const PyArray_Descr *descr)
-        {
-            if (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION) {
-                return _PyDataType_GetArrFuncs(descr);
-            }
-            else {
-                return ((PyArray_DescrProto *)descr)->f;
-            }
-        }
-    #endif
-
-
-    #endif  /* not internal build */
-
-    #endif  /* NUMPY_CORE_INCLUDE_NUMPY_NPY_2_COMPAT_H_ */
-
-    """)

pytensor/tensor/extra_ops.py

@@ -18,7 +18,7 @@ from pytensor.graph.replace import _vectorize_node
 from pytensor.link.c.op import COp
 from pytensor.link.c.params_type import ParamsType
 from pytensor.link.c.type import EnumList, Generic
-from pytensor.npy_2_compat import npy_2_compat_header, old_np_unique
+from pytensor.npy_2_compat import old_np_unique
 from pytensor.raise_op import Assert
 from pytensor.scalar import int64 as int_t
 from pytensor.scalar import upcast
@@ -362,10 +362,6 @@ class CumOp(COp):
 
         return shapes
 
-    def c_support_code_apply(self, node: Apply, name: str) -> str:
-        """Needed to define NPY_RAVEL_AXIS"""
-        return npy_2_compat_header()
-
     def c_code(self, node, name, inames, onames, sub):
         (x,) = inames
         (z,) = onames
@@ -424,7 +420,7 @@ class CumOp(COp):
         return code
 
     def c_code_cache_version(self):
-        return (9,)
+        return (10,)
 
     def __str__(self):
         return f"{self.__class__.__name__}{{{self.axis}, {self.mode}}}"

pytensor/tensor/math.py

@@ -14,7 +14,6 @@ from pytensor.graph.op import Op
 from pytensor.graph.replace import _vectorize_node
 from pytensor.link.c.op import COp
 from pytensor.link.c.params_type import ParamsType
-from pytensor.npy_2_compat import npy_2_compat_header
 from pytensor.printing import pprint
 from pytensor.raise_op import Assert
 from pytensor.scalar.basic import BinaryScalarOp
@@ -205,10 +204,6 @@ class Argmax(COp):
 
         max_idx[0] = np.asarray(np.argmax(reshaped_x, axis=-1), dtype="int64")
 
-    def c_support_code_apply(self, node: Apply, name: str) -> str:
-        """Needed to define NPY_RAVEL_AXIS"""
-        return npy_2_compat_header()
-
     def c_code(self, node, name, inp, out, sub):
         (x,) = inp
         (argmax,) = out
@@ -255,7 +250,7 @@ class Argmax(COp):
         """
 
     def c_code_cache_version(self):
-        return (2,)
+        return (3,)
 
     def infer_shape(self, fgraph, node, shapes):
         (ishape,) = shapes

pytensor/tensor/special.py

@@ -6,7 +6,6 @@ import scipy
 from pytensor.graph.basic import Apply
 from pytensor.graph.replace import _vectorize_node
 from pytensor.link.c.op import COp
-from pytensor.npy_2_compat import npy_2_compat_header
 from pytensor.tensor.basic import as_tensor_variable
 from pytensor.tensor.elemwise import get_normalized_batch_axes
 from pytensor.tensor.math import gamma, gammaln, log, neg, sum
@@ -61,11 +60,7 @@ class SoftmaxGrad(COp):
         return [shape[1]]
 
     def c_code_cache_version(self):
-        return (5,)
-
-    def c_support_code_apply(self, node: Apply, name: str) -> str:
-        # return super().c_support_code_apply(node, name)
-        return npy_2_compat_header()
+        return (6,)
 
     def c_code(self, node, name, inp, out, sub):
         dy, sm = inp
@@ -296,10 +291,6 @@ class Softmax(COp):
     def c_headers(self, **kwargs):
         return ["<cmath>"]
 
-    def c_support_code_apply(self, node: Apply, name: str) -> str:
-        """Needed to define NPY_RAVEL_AXIS"""
-        return npy_2_compat_header()
-
     def c_code(self, node, name, inp, out, sub):
         (x,) = inp
         (sm,) = out
@@ -495,7 +486,7 @@ class Softmax(COp):
 
     @staticmethod
     def c_code_cache_version():
-        return (5,)
+        return (6,)
 
 
 def softmax(c, axis=None):
@@ -555,10 +546,6 @@ class LogSoftmax(COp):
     def c_headers(self, **kwargs):
         return ["<cmath>"]
 
-    def c_support_code_apply(self, node: Apply, name: str) -> str:
-        """Needed to define NPY_RAVEL_AXIS"""
-        return npy_2_compat_header()
-
     def c_code(self, node, name, inp, out, sub):
         (x,) = inp
         (sm,) = out
@@ -750,7 +737,7 @@ class LogSoftmax(COp):
 
     @staticmethod
     def c_code_cache_version():
-        return (2,)
+        return (3,)
 
 
 def log_softmax(c, axis=None):