MNT: move cached imports into a global struct

Author: ngoldbaum

numpy/_core/src/common/npy_ctypes.h

@@ -4,6 +4,7 @@
 #include <Python.h>
 
 #include "npy_import.h"
+#include "multiarraymodule.h"
 
 /*
  * Check if a python type is a ctypes class.
@@ -17,16 +18,17 @@
 static inline int
 npy_ctypes_check(PyTypeObject *obj)
 {
-    static PyObject *py_func = NULL;
     PyObject *ret_obj;
     int ret;
 
-    npy_cache_import("numpy._core._internal", "npy_ctypes_check", &py_func);
-    if (py_func == NULL) {
+    npy_cache_import("numpy._core._internal", "npy_ctypes_check",
+                     &npy_ma_global_data->npy_ctypes_check);
+    if (npy_ma_global_data->npy_ctypes_check == NULL) {
         goto fail;
     }
 
-    ret_obj = PyObject_CallFunctionObjArgs(py_func, (PyObject *)obj, NULL);
+    ret_obj = PyObject_CallFunctionObjArgs(npy_ma_global_data->npy_ctypes_check,
+                                           (PyObject *)obj, NULL);
     if (ret_obj == NULL) {
         goto fail;
     }

numpy/_core/src/multiarray/arrayfunction_override.c

@@ -252,14 +252,14 @@ get_args_and_kwargs(
 static void
 set_no_matching_types_error(PyObject *public_api, PyObject *types)
 {
-    static PyObject *errmsg_formatter = NULL;
     /* No acceptable override found, raise TypeError. */
     npy_cache_import("numpy._core._internal",
                      "array_function_errmsg_formatter",
-                     &errmsg_formatter);
-    if (errmsg_formatter != NULL) {
+                     &npy_ma_global_data->array_function_errmsg_formatter);
+    if (npy_ma_global_data->array_function_errmsg_formatter != NULL) {
         PyObject *errmsg = PyObject_CallFunctionObjArgs(
-                errmsg_formatter, public_api, types, NULL);
+                npy_ma_global_data->array_function_errmsg_formatter,
+                public_api, types, NULL);
         if (errmsg != NULL) {
             PyErr_SetObject(PyExc_TypeError, errmsg);
             Py_DECREF(errmsg);

numpy/_core/src/multiarray/arrayobject.c

@@ -927,7 +927,8 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op)
      */
     if (result == NULL
             && (cmp_op == Py_EQ || cmp_op == Py_NE)
-            && PyErr_ExceptionMatches(npy_UFuncNoLoopError)) {
+            && PyErr_ExceptionMatches(
+                    npy_ma_global_data->_UFuncNoLoopError)) {
         PyErr_Clear();
 
         PyArrayObject *array_other = (PyArrayObject *)PyArray_FROM_O(other);

numpy/_core/src/multiarray/common.h

@@ -8,6 +8,7 @@
 #include "npy_cpu_dispatch.h"
 #include "numpy/npy_cpu.h"
 
+#include "multiarraymodule.h"
 #include "npy_import.h"
 #include <limits.h>
 
@@ -139,25 +140,14 @@ check_and_adjust_axis_msg(int *axis, int ndim, PyObject *msg_prefix)
 {
     /* Check that index is valid, taking into account negative indices */
     if (NPY_UNLIKELY((*axis < -ndim) || (*axis >= ndim))) {
-        /*
-         * Load the exception type, if we don't already have it. Unfortunately
-         * we don't have access to npy_cache_import here
-         */
-        static PyObject *AxisError_cls = NULL;
-        PyObject *exc;
-
-        npy_cache_import("numpy.exceptions", "AxisError", &AxisError_cls);
-        if (AxisError_cls == NULL) {
-            return -1;
-        }
-
         /* Invoke the AxisError constructor */
-        exc = PyObject_CallFunction(AxisError_cls, "iiO",
-                                    *axis, ndim, msg_prefix);
+        PyObject *exc = PyObject_CallFunction(
+                npy_ma_global_data->AxisError, "iiO", *axis, ndim,
+                msg_prefix);
         if (exc == NULL) {
             return -1;
         }
-        PyErr_SetObject(AxisError_cls, exc);
+        PyErr_SetObject(npy_ma_global_data->AxisError, exc);
         Py_DECREF(exc);
 
         return -1;

numpy/_core/src/multiarray/common_dtype.c

@@ -10,6 +10,7 @@
 #include "convert_datatype.h"
 #include "dtypemeta.h"
 #include "abstractdtypes.h"
+#include "multiarraymodule.h"
 
 
 /*
@@ -63,7 +64,7 @@ PyArray_CommonDType(PyArray_DTypeMeta *dtype1, PyArray_DTypeMeta *dtype2)
     }
     if (common_dtype == (PyArray_DTypeMeta *)Py_NotImplemented) {
         Py_DECREF(Py_NotImplemented);
-        PyErr_Format(npy_DTypePromotionError,
+        PyErr_Format(npy_ma_global_data->DTypePromotionError,
                 "The DTypes %S and %S do not have a common DType. "
                 "For example they cannot be stored in a single array unless "
                 "the dtype is `object`.", dtype1, dtype2);
@@ -284,7 +285,7 @@ PyArray_PromoteDTypeSequence(
                 Py_INCREF(dtypes_in[l]);
                 PyTuple_SET_ITEM(dtypes_in_tuple, l, (PyObject *)dtypes_in[l]);
             }
-            PyErr_Format(npy_DTypePromotionError,
+            PyErr_Format(npy_ma_global_data->DTypePromotionError,
                     "The DType %S could not be promoted by %S. This means that "
                     "no common DType exists for the given inputs. "
                     "For example they cannot be stored in a single array unless "

numpy/_core/src/multiarray/conversion_utils.c

@@ -234,10 +234,8 @@ PyArray_CopyConverter(PyObject *obj, NPY_COPYMODE *copymode) {
     }
 
     int int_copymode;
-    static PyObject* numpy_CopyMode = NULL;
-    npy_cache_import("numpy", "_CopyMode", &numpy_CopyMode);
 
-    if (numpy_CopyMode != NULL && (PyObject *)Py_TYPE(obj) == numpy_CopyMode) {
+    if ((PyObject *)Py_TYPE(obj) == npy_ma_global_data->_CopyMode) {
         PyObject* mode_value = PyObject_GetAttrString(obj, "value");
         if (mode_value == NULL) {
             return NPY_FAIL;
@@ -271,10 +269,8 @@ NPY_NO_EXPORT int
 PyArray_AsTypeCopyConverter(PyObject *obj, NPY_ASTYPECOPYMODE *copymode)
 {
     int int_copymode;
-    static PyObject* numpy_CopyMode = NULL;
-    npy_cache_import("numpy", "_CopyMode", &numpy_CopyMode);
 
-    if (numpy_CopyMode != NULL && (PyObject *)Py_TYPE(obj) == numpy_CopyMode) {
+    if ((PyObject *)Py_TYPE(obj) == npy_ma_global_data->_CopyMode) {
         PyErr_SetString(PyExc_ValueError,
                         "_CopyMode enum is not allowed for astype function. "
                         "Use true/false instead.");
@@ -1415,12 +1411,7 @@ PyArray_IntTupleFromIntp(int len, npy_intp const *vals)
 NPY_NO_EXPORT int
 _not_NoValue(PyObject *obj, PyObject **out)
 {
-    static PyObject *NoValue = NULL;
-    npy_cache_import("numpy", "_NoValue", &NoValue);
-    if (NoValue == NULL) {
-        return 0;
-    }
-    if (obj == NoValue) {
+    if (obj == npy_ma_global_data->_NoValue) {
         *out = NULL;
     }
     else {

numpy/_core/src/multiarray/convert_datatype.c

@@ -48,14 +48,6 @@
  */
 NPY_NO_EXPORT npy_intp REQUIRED_STR_LEN[] = {0, 3, 5, 10, 10, 20, 20, 20, 20};
 
-/*
- * Whether or not legacy value-based promotion/casting is used.
- */
-
-NPY_NO_EXPORT PyObject *NO_NEP50_WARNING_CTX = NULL;
-NPY_NO_EXPORT PyObject *npy_DTypePromotionError = NULL;
-NPY_NO_EXPORT PyObject *npy_UFuncNoLoopError = NULL;
-
 static NPY_TLS int npy_promotion_state = NPY_USE_LEGACY_PROMOTION;
 
 NPY_NO_EXPORT int
@@ -92,13 +84,14 @@ npy_give_promotion_warnings(void)
 
     npy_cache_import(
             "numpy._core._ufunc_config", "NO_NEP50_WARNING",
-            &NO_NEP50_WARNING_CTX);
-    if (NO_NEP50_WARNING_CTX == NULL) {
+            &npy_ma_global_data->NO_NEP50_WARNING);
+    if (npy_ma_global_data->NO_NEP50_WARNING == NULL) {
         PyErr_WriteUnraisable(NULL);
         return 1;
     }
 
-    if (PyContextVar_Get(NO_NEP50_WARNING_CTX, Py_False, &val) < 0) {
+    if (PyContextVar_Get(npy_ma_global_data->NO_NEP50_WARNING,
+                         Py_False, &val) < 0) {
         /* Errors should not really happen, but if it does assume we warn. */
         PyErr_WriteUnraisable(NULL);
         return 1;
@@ -409,12 +402,7 @@ PyArray_GetCastFunc(PyArray_Descr *descr, int type_num)
             !PyTypeNum_ISCOMPLEX(type_num) &&
             PyTypeNum_ISNUMBER(type_num) &&
             !PyTypeNum_ISBOOL(type_num)) {
-        static PyObject *cls = NULL;
-        npy_cache_import("numpy.exceptions", "ComplexWarning", &cls);
-        if (cls == NULL) {
-            return NULL;
-        }
-        int ret = PyErr_WarnEx(cls,
+        int ret = PyErr_WarnEx(npy_ma_global_data->ComplexWarning,
                 "Casting complex values to real discards "
                 "the imaginary part", 1);
         if (ret < 0) {
@@ -2638,13 +2626,7 @@ complex_to_noncomplex_get_loop(
         PyArrayMethod_StridedLoop **out_loop, NpyAuxData **out_transferdata,
         NPY_ARRAYMETHOD_FLAGS *flags)
 {
-    static PyObject *cls = NULL;
-    int ret;
-    npy_cache_import("numpy.exceptions", "ComplexWarning", &cls);
-    if (cls == NULL) {
-        return -1;
-    }
-    ret = PyErr_WarnEx(cls,
+    int ret = PyErr_WarnEx(npy_ma_global_data->ComplexWarning,
             "Casting complex values to real discards "
             "the imaginary part", 1);
     if (ret < 0) {

numpy/_core/src/multiarray/convert_datatype.h

@@ -13,10 +13,6 @@ extern NPY_NO_EXPORT npy_intp REQUIRED_STR_LEN[];
 #define NPY_USE_WEAK_PROMOTION 1
 #define NPY_USE_WEAK_PROMOTION_AND_WARN 2
 
-extern NPY_NO_EXPORT PyObject *NO_NEP50_WARNING_CTX;
-extern NPY_NO_EXPORT PyObject *npy_DTypePromotionError;
-extern NPY_NO_EXPORT PyObject *npy_UFuncNoLoopError;
-
 NPY_NO_EXPORT int
 npy_give_promotion_warnings(void);
 

numpy/_core/src/multiarray/ctors.c

@@ -611,15 +611,6 @@ PyArray_AssignFromCache(PyArrayObject *self, coercion_cache_obj *cache) {
 static void
 raise_memory_error(int nd, npy_intp const *dims, PyArray_Descr *descr)
 {
-    static PyObject *exc_type = NULL;
-
-    npy_cache_import(
-        "numpy._core._exceptions", "_ArrayMemoryError",
-        &exc_type);
-    if (exc_type == NULL) {
-        goto fail;
-    }
-
     PyObject *shape = PyArray_IntTupleFromIntp(nd, dims);
     if (shape == NULL) {
         goto fail;
@@ -631,7 +622,7 @@ raise_memory_error(int nd, npy_intp const *dims, PyArray_Descr *descr)
     if (exc_value == NULL){
         goto fail;
     }
-    PyErr_SetObject(exc_type, exc_value);
+    PyErr_SetObject(npy_ma_global_data->_ArrayMemoryError, exc_value);
     Py_DECREF(exc_value);
     return;
 

numpy/_core/src/multiarray/descriptor.c

@@ -724,13 +724,13 @@ _convert_from_commastring(PyObject *obj, int align)
 {
     PyObject *parsed;
     PyArray_Descr *res;
-    static PyObject *_commastring = NULL;
     assert(PyUnicode_Check(obj));
-    npy_cache_import("numpy._core._internal", "_commastring", &_commastring);
-    if (_commastring == NULL) {
+    npy_cache_import("numpy._core._internal", "_commastring",
+                     &npy_ma_global_data->_commastring);
+    if (npy_ma_global_data->_commastring == NULL) {
         return NULL;
     }
-    parsed = PyObject_CallOneArg(_commastring, obj);
+    parsed = PyObject_CallOneArg(npy_ma_global_data->_commastring, obj);
     if (parsed == NULL) {
         return NULL;
     }