Remove using_numpy_2

Author: Armavica

pytensor/npy_2_compat.py

@@ -3,21 +3,12 @@
 import numpy as np
 
 
-numpy_version_tuple = tuple(int(n) for n in np.__version__.split(".")[:2])
-numpy_version = np.lib.NumpyVersion(
-    np.__version__
-)  # used to compare with version strings, e.g. numpy_version < "1.16.0"
-using_numpy_2 = numpy_version >= "2.0.0rc1"
-
-
-
-
 # function that replicates np.unique from numpy < 2.0
 def old_np_unique(
     arr, return_index=False, return_inverse=False, return_counts=False, axis=None
 ):
     """Replicate np.unique from numpy versions < 2.0"""
-    if not return_inverse or not using_numpy_2:
+    if not return_inverse:
         return np.unique(arr, return_index, return_inverse, return_counts, axis)
 
     outs = list(np.unique(arr, return_index, return_inverse, return_counts, axis))

pytensor/tensor/subtensor.py

@@ -6,6 +6,7 @@
 from typing import cast, overload
 
 import numpy as np
+from numpy.lib.array_utils import normalize_axis_tuple
 
 import pytensor
 from pytensor import scalar as ps
@@ -18,7 +19,6 @@
 from pytensor.graph.utils import MethodNotDefined
 from pytensor.link.c.op import COp
 from pytensor.link.c.params_type import ParamsType
-from pytensor.npy_2_compat import normalize_axis_tuple, numpy_version, using_numpy_2
 from pytensor.printing import Printer, pprint, set_precedence
 from pytensor.scalar.basic import ScalarConstant, ScalarVariable
 from pytensor.tensor import (
@@ -2330,199 +2330,6 @@ def copy_of_x(self, x):
         return f"""(PyArrayObject*)PyArray_FromAny(py_{x}, NULL, 0, 0,
                 NPY_ARRAY_ENSURECOPY, NULL)"""
 
-    def c_support_code(self, **kwargs):
-        if numpy_version < "1.8.0" or using_numpy_2:
-            return None
-
-        types = [
-            "npy_" + t
-            for t in [
-                "int8",
-                "int16",
-                "int32",
-                "int64",
-                "uint8",
-                "uint16",
-                "uint32",
-                "uint64",
-                "float16",
-                "float32",
-                "float64",
-            ]
-        ]
-
-        complex_types = ["npy_" + t for t in ("complex32", "complex64", "complex128")]
-
-        inplace_map_template = """
-        #if defined(%(typen)s)
-        static void %(type)s_inplace_add(PyArrayMapIterObject *mit,
-                                        PyArrayIterObject *it, int inc_or_set)
-        {
-            int index = mit->size;
-            while (index--) {
-                %(op)s
-
-                PyArray_MapIterNext(mit);
-                PyArray_ITER_NEXT(it);
-            }
-        }
-        #endif
-        """
-
-        floatadd = (
-            "((%(type)s*)mit->dataptr)[0] = "
-            "(inc_or_set ? ((%(type)s*)mit->dataptr)[0] : 0)"
-            " + ((%(type)s*)it->dataptr)[0];"
-        )
-        complexadd = """
-        ((%(type)s*)mit->dataptr)[0].real =
-            (inc_or_set ? ((%(type)s*)mit->dataptr)[0].real : 0)
-            + ((%(type)s*)it->dataptr)[0].real;
-        ((%(type)s*)mit->dataptr)[0].imag =
-            (inc_or_set ? ((%(type)s*)mit->dataptr)[0].imag : 0)
-            + ((%(type)s*)it->dataptr)[0].imag;
-        """
-
-        fns = "".join(
-            [
-                inplace_map_template
-                % {"type": t, "typen": t.upper(), "op": floatadd % {"type": t}}
-                for t in types
-            ]
-            + [
-                inplace_map_template
-                % {"type": t, "typen": t.upper(), "op": complexadd % {"type": t}}
-                for t in complex_types
-            ]
-        )
-
-        def gen_binop(type, typen):
-            return f"""
-    #if defined({typen})
-    {type}_inplace_add,
-    #endif
-    """
-
-        fn_array = (
-            "static inplace_map_binop addition_funcs[] = {"
-            + "".join(gen_binop(type=t, typen=t.upper()) for t in types + complex_types)
-            + "NULL};\n"
-        )
-
-        def gen_num(typen):
-            return f"""
-    #if defined({typen})
-    {typen},
-    #endif
-    """
-
-        type_number_array = (
-            "static int type_numbers[] = {"
-            + "".join(gen_num(typen=t.upper()) for t in types + complex_types)
-            + "-1000};"
-        )
-
-        code = (
-            """
-            typedef void (*inplace_map_binop)(PyArrayMapIterObject *,
-                                            PyArrayIterObject *, int inc_or_set);
-            """
-            + fns
-            + fn_array
-            + type_number_array
-            + """
-    static int
-    map_increment(PyArrayMapIterObject *mit, PyArrayObject *op,
-                inplace_map_binop add_inplace, int inc_or_set)
-    {
-        PyArrayObject *arr = NULL;
-        PyArrayIterObject *it;
-        PyArray_Descr *descr;
-        if (mit->ait == NULL) {
-            return -1;
-        }
-        descr = PyArray_DESCR(mit->ait->ao);
-        Py_INCREF(descr);
-        arr = (PyArrayObject *)PyArray_FromAny((PyObject *)op, descr,
-                                    0, 0, NPY_ARRAY_FORCECAST, NULL);
-        if (arr == NULL) {
-            return -1;
-        }
-        if ((mit->subspace != NULL) && (mit->consec)) {
-            PyArray_MapIterSwapAxes(mit, (PyArrayObject **)&arr, 0);
-            if (arr == NULL) {
-                return -1;
-            }
-        }
-        it = (PyArrayIterObject*)
-                PyArray_BroadcastToShape((PyObject*)arr, mit->dimensions, mit->nd);
-        if (it  == NULL) {
-            Py_DECREF(arr);
-            return -1;
-        }
-
-        (*add_inplace)(mit, it, inc_or_set);
-
-        Py_DECREF(arr);
-        Py_DECREF(it);
-        return 0;
-    }
-
-
-    static int
-    inplace_increment(PyArrayObject *a, PyObject *index, PyArrayObject *inc,
-                    int inc_or_set)
-    {
-        inplace_map_binop add_inplace = NULL;
-        int type_number = -1;
-        int i = 0;
-        PyArrayMapIterObject * mit;
-
-        if (PyArray_FailUnlessWriteable(a, "input/output array") < 0) {
-            return -1;
-        }
-
-        if (PyArray_NDIM(a) == 0) {
-            PyErr_SetString(PyExc_IndexError, "0-d arrays can't be indexed.");
-            return -1;
-        }
-        type_number = PyArray_TYPE(a);
-
-        while (type_numbers[i] >= 0 && addition_funcs[i] != NULL){
-            if (type_number == type_numbers[i]) {
-                add_inplace = addition_funcs[i];
-                break;
-            }
-            i++ ;
-        }
-
-        if (add_inplace == NULL) {
-            PyErr_SetString(PyExc_TypeError, "unsupported type for a");
-            return -1;
-        }
-        mit = (PyArrayMapIterObject *) PyArray_MapIterArray(a, index);
-        if (mit == NULL) {
-            goto fail;
-        }
-        if (map_increment(mit, inc, add_inplace, inc_or_set) != 0) {
-            goto fail;
-        }
-
-        Py_DECREF(mit);
-
-        Py_INCREF(Py_None);
-        return 0;
-
-    fail:
-        Py_XDECREF(mit);
-
-        return -1;
-    }
-    """
-        )
-
-        return code
-
     def c_code(self, node, name, input_names, output_names, sub):
         x, y, idx = input_names
         [out] = output_names
@@ -2636,34 +2443,7 @@ def c_code(self, node, name, input_names, output_names, sub):
             """
             return code
 
-        if numpy_version < "1.8.0" or using_numpy_2:
-            raise NotImplementedError
-
-        return f"""
-        PyObject* rval = NULL;
-        if ({params}->inplace)
-        {{
-            if ({x} != {out})
-            {{
-                Py_XDECREF({out});
-                Py_INCREF({x});
-                {out} = {x};
-            }}
-        }}
-        else
-        {{
-            Py_XDECREF({out});
-            {out} = {copy_of_x};
-            if (!{out}) {{
-                // Exception already set
-                {fail}
-            }}
-        }}
-        if (inplace_increment({out}, (PyObject *){idx}, {y}, (1 - {params}->set_instead_of_inc))) {{
-            {fail};
-        }}
-        Py_XDECREF(rval);
-        """
+        raise NotImplementedError
 
     def c_code_cache_version(self):
         return (10,)

tests/tensor/test_math.py

@@ -24,7 +24,6 @@
 from pytensor.graph.replace import vectorize_node
 from pytensor.graph.traversal import ancestors, applys_between
 from pytensor.link.c.basic import DualLinker
-from pytensor.npy_2_compat import using_numpy_2
 from pytensor.printing import pprint
 from pytensor.raise_op import Assert
 from pytensor.tensor import blas, blas_c
@@ -399,10 +398,7 @@ def test_maximum_minimum_grad():
 
 # in numpy >= 2.0, negating a uint raises an error
 neg_good = _good_broadcast_unary_normal.copy()
-if using_numpy_2:
-    neg_bad = {"uint8": neg_good.pop("uint8"), "uint16": neg_good.pop("uint16")}
-else:
-    neg_bad = None
+neg_bad = {"uint8": neg_good.pop("uint8"), "uint16": neg_good.pop("uint16")}
 
 TestNegBroadcast = makeBroadcastTester(
     op=neg,