MNT: apply sebastian's refactoring suggestions

Author: ngoldbaum

numpy/_core/src/common/npy_cpu_dispatch.c

@@ -8,7 +8,7 @@
 NPY_VISIBILITY_HIDDEN int
 npy_cpu_dispatch_tracer_init(PyObject *mod)
 {
-    if (npy_ma_static_data.cpu_dispatch_registry != NULL) {
+    if (npy_static_pydata.cpu_dispatch_registry != NULL) {
         PyErr_Format(PyExc_RuntimeError, "CPU dispatcher tracer already initlized");
         return -1;
     }
@@ -25,21 +25,21 @@ npy_cpu_dispatch_tracer_init(PyObject *mod)
     if (err != 0) {
         return -1;
     }
-    npy_ma_static_data.cpu_dispatch_registry = reg_dict;
+    npy_static_pydata.cpu_dispatch_registry = reg_dict;
     return 0;
 }
 
 NPY_VISIBILITY_HIDDEN void
 npy_cpu_dispatch_trace(const char *fname, const char *signature,
                        const char **dispatch_info)
 {
-    PyObject *func_dict = PyDict_GetItemString(npy_ma_static_data.cpu_dispatch_registry, fname);
+    PyObject *func_dict = PyDict_GetItemString(npy_static_pydata.cpu_dispatch_registry, fname);
     if (func_dict == NULL) {
         func_dict = PyDict_New();
         if (func_dict == NULL) {
             return;
         }
-        int err = PyDict_SetItemString(npy_ma_static_data.cpu_dispatch_registry, fname, func_dict);
+        int err = PyDict_SetItemString(npy_static_pydata.cpu_dispatch_registry, fname, func_dict);
         Py_DECREF(func_dict);
         if (err != 0) {
             return;

numpy/_core/src/common/npy_ctypes.h

@@ -22,12 +22,12 @@ npy_ctypes_check(PyTypeObject *obj)
     int ret;
 
     npy_cache_import("numpy._core._internal", "npy_ctypes_check",
-                     &npy_ma_thread_unsafe_state.npy_ctypes_check);
-    if (npy_ma_thread_unsafe_state.npy_ctypes_check == NULL) {
+                     &npy_thread_unsafe_state.npy_ctypes_check);
+    if (npy_thread_unsafe_state.npy_ctypes_check == NULL) {
         goto fail;
     }
 
-    ret_obj = PyObject_CallFunctionObjArgs(npy_ma_thread_unsafe_state.npy_ctypes_check,
+    ret_obj = PyObject_CallFunctionObjArgs(npy_thread_unsafe_state.npy_ctypes_check,
                                            (PyObject *)obj, NULL);
     if (ret_obj == NULL) {
         goto fail;

numpy/_core/src/common/ufunc_override.c

@@ -43,7 +43,7 @@ PyUFuncOverride_GetNonDefaultArrayUfunc(PyObject *obj)
         return NULL;
     }
     /* Ignore if the same as ndarray.__array_ufunc__ */
-    if (cls_array_ufunc == npy_ma_static_data.ndarray_array_ufunc) {
+    if (cls_array_ufunc == npy_static_pydata.ndarray_array_ufunc) {
         Py_DECREF(cls_array_ufunc);
         return NULL;
     }

numpy/_core/src/multiarray/alloc.c

@@ -48,7 +48,7 @@ NPY_NO_EXPORT PyObject *
 _get_madvise_hugepage(PyObject *NPY_UNUSED(self), PyObject *NPY_UNUSED(args))
 {
 #ifdef NPY_OS_LINUX
-    if (npy_ma_thread_unsafe_state.madvise_hugepage) {
+    if (npy_thread_unsafe_state.madvise_hugepage) {
         Py_RETURN_TRUE;
     }
 #endif
@@ -66,12 +66,12 @@ _get_madvise_hugepage(PyObject *NPY_UNUSED(self), PyObject *NPY_UNUSED(args))
 NPY_NO_EXPORT PyObject *
 _set_madvise_hugepage(PyObject *NPY_UNUSED(self), PyObject *enabled_obj)
 {
-    int was_enabled = npy_ma_thread_unsafe_state.madvise_hugepage;
+    int was_enabled = npy_thread_unsafe_state.madvise_hugepage;
     int enabled = PyObject_IsTrue(enabled_obj);
     if (enabled < 0) {
         return NULL;
     }
-    npy_ma_thread_unsafe_state.madvise_hugepage = enabled;
+    npy_thread_unsafe_state.madvise_hugepage = enabled;
     if (was_enabled) {
         Py_RETURN_TRUE;
     }
@@ -110,7 +110,7 @@ _npy_alloc_cache(npy_uintp nelem, npy_uintp esz, npy_uint msz,
 #ifdef NPY_OS_LINUX
         /* allow kernel allocating huge pages for large arrays */
         if (NPY_UNLIKELY(nelem * esz >= ((1u<<22u))) &&
-            npy_ma_thread_unsafe_state.madvise_hugepage) {
+            npy_thread_unsafe_state.madvise_hugepage) {
             npy_uintp offset = 4096u - (npy_uintp)p % (4096u);
             npy_uintp length = nelem * esz - offset;
             /**

numpy/_core/src/multiarray/array_converter.c

@@ -186,8 +186,8 @@ static int
 pyscalar_mode_conv(PyObject *obj, scalar_policy *policy)
 {
     PyObject *strings[3] = {
-            npy_ma_str.convert, npy_ma_str.preserve,
-            npy_ma_str.convert_if_no_array};
+            npy_interned_str.convert, npy_interned_str.preserve,
+            npy_interned_str.convert_if_no_array};
 
     /* First quick pass using the identity (should practically always match) */
     for (int i = 0; i < 3; i++) {

numpy/_core/src/multiarray/arrayfunction_override.c

@@ -20,11 +20,11 @@ get_array_function(PyObject *obj)
 {
     /* Fast return for ndarray */
     if (PyArray_CheckExact(obj)) {
-        Py_INCREF(npy_ma_static_data.ndarray_array_function);
-        return npy_ma_static_data.ndarray_array_function;
+        Py_INCREF(npy_static_pydata.ndarray_array_function);
+        return npy_static_pydata.ndarray_array_function;
     }
 
-    PyObject *array_function = PyArray_LookupSpecial(obj, npy_ma_str.array_function);
+    PyObject *array_function = PyArray_LookupSpecial(obj, npy_interned_str.array_function);
     if (array_function == NULL && PyErr_Occurred()) {
         PyErr_Clear(); /* TODO[gh-14801]: propagate crashes during attribute access? */
     }
@@ -125,7 +125,7 @@ get_implementing_args_and_methods(PyObject *relevant_args,
 static int
 is_default_array_function(PyObject *obj)
 {
-    return obj == npy_ma_static_data.ndarray_array_function;
+    return obj == npy_static_pydata.ndarray_array_function;
 }
 
 
@@ -153,7 +153,7 @@ array_function_method_impl(PyObject *func, PyObject *types, PyObject *args,
         }
     }
 
-    PyObject *implementation = PyObject_GetAttr(func, npy_ma_str.implementation);
+    PyObject *implementation = PyObject_GetAttr(func, npy_interned_str.implementation);
     if (implementation == NULL) {
         return NULL;
     }
@@ -233,10 +233,10 @@ set_no_matching_types_error(PyObject *public_api, PyObject *types)
     /* No acceptable override found, raise TypeError. */
     npy_cache_import("numpy._core._internal",
                      "array_function_errmsg_formatter",
-                     &npy_ma_thread_unsafe_state.array_function_errmsg_formatter);
-    if (npy_ma_thread_unsafe_state.array_function_errmsg_formatter != NULL) {
+                     &npy_thread_unsafe_state.array_function_errmsg_formatter);
+    if (npy_thread_unsafe_state.array_function_errmsg_formatter != NULL) {
         PyObject *errmsg = PyObject_CallFunctionObjArgs(
-                npy_ma_thread_unsafe_state.array_function_errmsg_formatter,
+                npy_thread_unsafe_state.array_function_errmsg_formatter,
                 public_api, types, NULL);
         if (errmsg != NULL) {
             PyErr_SetObject(PyExc_TypeError, errmsg);
@@ -299,12 +299,12 @@ array_implement_c_array_function_creation(
     }
 
     /* The like argument must be present in the keyword arguments, remove it */
-    if (PyDict_DelItem(kwargs, npy_ma_str.like) < 0) {
+    if (PyDict_DelItem(kwargs, npy_interned_str.like) < 0) {
         goto finish;
     }
 
     /* Fetch the actual symbol (the long way right now) */
-    numpy_module = PyImport_Import(npy_ma_str.numpy);
+    numpy_module = PyImport_Import(npy_interned_str.numpy);
     if (numpy_module == NULL) {
         goto finish;
     }

numpy/_core/src/multiarray/arrayobject.c

@@ -928,7 +928,7 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op)
     if (result == NULL
             && (cmp_op == Py_EQ || cmp_op == Py_NE)
             && PyErr_ExceptionMatches(
-                    npy_ma_static_data._UFuncNoLoopError)) {
+                    npy_static_pydata._UFuncNoLoopError)) {
         PyErr_Clear();
 
         PyArrayObject *array_other = (PyArrayObject *)PyArray_FROM_O(other);

numpy/_core/src/multiarray/arraytypes.c.src

@@ -4185,7 +4185,7 @@ NPY_NO_EXPORT _PyArray_LegacyDescr @from@_Descr = {
 
 /* The smallest type number is ?, the largest bounded by 'z'. */
 #define _MAX_LETTER ('z' + 1)
-#define LETTER_TO_NUM(letter) npy_ma_static_data._letter_to_num[letter - '?']
+#define LETTER_TO_NUM(letter) npy_static_cdata._letter_to_num[letter - '?']
 
 static _PyArray_LegacyDescr *_builtin_descrs[] = {
     &BOOL_Descr,

numpy/_core/src/multiarray/arraywrap.c

@@ -57,7 +57,7 @@ npy_find_array_wrap(
             }
         }
         else {
-            PyObject *new_wrap = PyArray_LookupSpecial_OnInstance(obj, npy_ma_str.array_wrap);
+            PyObject *new_wrap = PyArray_LookupSpecial_OnInstance(obj, npy_interned_str.array_wrap);
             if (new_wrap == NULL) {
                 if (PyErr_Occurred()) {
                     goto fail;
@@ -160,7 +160,7 @@ npy_apply_wrap(
         else {
             /* Replace passed wrap/wrap_type (borrowed refs) with new_wrap/type. */
             new_wrap = PyArray_LookupSpecial_OnInstance(
-                    original_out, npy_ma_str.array_wrap);
+                    original_out, npy_interned_str.array_wrap);
             if (new_wrap != NULL) {
                 wrap = new_wrap;
                 wrap_type = (PyObject *)Py_TYPE(original_out);

numpy/_core/src/multiarray/common.h

@@ -142,12 +142,12 @@ check_and_adjust_axis_msg(int *axis, int ndim, PyObject *msg_prefix)
     if (NPY_UNLIKELY((*axis < -ndim) || (*axis >= ndim))) {
         /* Invoke the AxisError constructor */
         PyObject *exc = PyObject_CallFunction(
-                npy_ma_static_data.AxisError, "iiO", *axis, ndim,
+                npy_static_pydata.AxisError, "iiO", *axis, ndim,
                 msg_prefix);
         if (exc == NULL) {
             return -1;
         }
-        PyErr_SetObject(npy_ma_static_data.AxisError, exc);
+        PyErr_SetObject(npy_static_pydata.AxisError, exc);
         Py_DECREF(exc);
 
         return -1;