MAINT: refactor to pass casting safety in

Author: ngoldbaum

numpy/_core/src/multiarray/ctors.c

@@ -1908,11 +1908,9 @@ PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags)
     }
 
     arrflags = PyArray_FLAGS(arr);
-    unsigned char viewable = PyArray_ViewableTypes(oldtype, newtype);
-    if (viewable < 0) {
-        Py_DECREF(newtype);
-        return NULL;
-    }
+    npy_intp view_offset;
+    npy_intp is_safe = PyArray_SafeCast(oldtype, newtype, &view_offset, NPY_NO_CASTING, 1);
+    npy_intp view_safe = (is_safe && (view_offset == 0));
 
            /* If a guaranteed copy was requested */
     copy = (flags & NPY_ARRAY_ENSURECOPY) ||
@@ -1928,7 +1926,7 @@ PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags)
            /* If a writeable array was requested, and arr is not */
            ((flags & NPY_ARRAY_WRITEABLE) &&
                    (!(arrflags & NPY_ARRAY_WRITEABLE))) ||
-           !viewable;
+           !view_safe;
 
     if (copy) {
         if (flags & NPY_ARRAY_ENSURENOCOPY ) {

numpy/_core/src/multiarray/multiarraymodule.c

@@ -1449,23 +1449,6 @@ PyArray_EquivTypes(PyArray_Descr *type1, PyArray_Descr *type2)
         return 1;
     }
 
-    if (Py_TYPE(Py_TYPE(type1)) == &PyType_Type) {
-        /*
-         * 2021-12-17: This case is nonsense and should be removed eventually!
-         *
-         * boost::python has/had a bug effectively using EquivTypes with
-         * `type(arbitrary_obj)`.  That is clearly wrong as that cannot be a
-         * `PyArray_Descr *`.  We assume that `type(type(type(arbitrary_obj))`
-         * is always in practice `type` (this is the type of the metaclass),
-         * but for our descriptors, `type(type(descr))` is DTypeMeta.
-         *
-         * In that case, we just return False.  There is a possibility that
-         * this actually _worked_ effectively (returning 1 sometimes).
-         * We ignore that possibility for simplicity; it really is not our bug.
-         */
-        return 0;
-    }
-
     /*
      * Do not use PyArray_CanCastTypeTo because it supports legacy flexible
      * dtypes as input.
@@ -1482,45 +1465,29 @@ PyArray_EquivTypes(PyArray_Descr *type1, PyArray_Descr *type2)
 
 
 /*
- * This function returns true if a view can be safely created
- * between the two types. This implies that PyArray_EquivTypes
- * is true as well.
+ * This function returns true if the two types can be safely cast at
+ * *minimum_safety* casting level. Sets the view_offset if that is set
+ * for the cast. If ignore_error is 1, errors in cast setup are ignored.
  */
-NPY_NO_EXPORT unsigned char
-PyArray_ViewableTypes(PyArray_Descr *type1, PyArray_Descr *type2)
+NPY_NO_EXPORT npy_intp
+PyArray_SafeCast(PyArray_Descr *type1, PyArray_Descr *type2,
+                 npy_intp* view_offset, NPY_CASTING minimum_safety,
+                 npy_intp ignore_error)
 {
     if (type1 == type2) {
+        *view_offset = 0;
         return 1;
     }
 
-    if (Py_TYPE(Py_TYPE(type1)) == &PyType_Type) {
-        /*
-         * 2021-12-17: This case is nonsense and should be removed eventually!
-         *
-         * boost::python has/had a bug effectively using EquivTypes with
-         * `type(arbitrary_obj)`.  That is clearly wrong as that cannot be a
-         * `PyArray_Descr *`.  We assume that `type(type(type(arbitrary_obj))`
-         * is always in practice `type` (this is the type of the metaclass),
-         * but for our descriptors, `type(type(descr))` is DTypeMeta.
-         *
-         * In that case, we just return False.  There is a possibility that
-         * this actually _worked_ effectively (returning 1 sometimes).
-         * We ignore that possibility for simplicity; it really is not our bug.
-         */
-        return 0;
-    }
-
-    npy_intp view_offset;
-    NPY_CASTING safety = PyArray_GetCastInfo(type1, type2, NULL, &view_offset);
+    NPY_CASTING safety = PyArray_GetCastInfo(type1, type2, NULL, view_offset);
     if (safety < 0) {
-        PyErr_Clear();
-        return 0;
-    }
-    if (view_offset != 0) {
-        return 0;
+        if (ignore_error) {
+            PyErr_Clear();
+            return 0;
+        }
+        return -1;
     }
-    /* If casting is "no casting" this dtypes are considered equivalent. */
-    return PyArray_MinCastSafety(safety, NPY_NO_CASTING) == NPY_NO_CASTING;
+    return PyArray_MinCastSafety(safety, minimum_safety) == minimum_safety;
 }
 
 
@@ -1652,11 +1619,10 @@ _array_fromobject_generic(
 
         /* One more chance for faster exit if user specified the dtype. */
         oldtype = PyArray_DESCR(oparr);
-        unsigned char viewable = PyArray_ViewableTypes(oldtype, dtype);
-        if (viewable < 0) {
-            goto finish;
-        }
-        if (viewable) {
+        npy_intp view_offset;
+        npy_intp is_safe = PyArray_SafeCast(oldtype, dtype, &view_offset, NPY_NO_CASTING, 1);
+        npy_intp view_safe = (is_safe && (view_offset == 0));
+        if (view_safe) {
             if (copy != NPY_COPY_ALWAYS && STRIDING_OK(oparr, order)) {
                 if (oldtype == dtype) {
                     Py_INCREF(op);

numpy/_core/src/multiarray/multiarraymodule.h

@@ -21,7 +21,9 @@ NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_convert_if_no_array;
 NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_cpu;
 NPY_VISIBILITY_HIDDEN extern PyObject * npy_ma_str_array_err_msg_substr;
 
-NPY_NO_EXPORT unsigned char
-PyArray_ViewableTypes(PyArray_Descr *type1, PyArray_Descr *type2);
+NPY_NO_EXPORT npy_intp
+PyArray_SafeCast(PyArray_Descr *type1, PyArray_Descr *type2,
+                 npy_intp* view_offset, NPY_CASTING minimum_safety,
+                 npy_intp ignore_errors);
 
 #endif  /* NUMPY_CORE_SRC_MULTIARRAY_MULTIARRAYMODULE_H_ */

numpy/_core/src/multiarray/stringdtype/casts.c

@@ -80,7 +80,9 @@ string_to_string_resolve_descriptors(PyObject *NPY_UNUSED(self),
     }
 
     // views are only legal between descriptors that share allocators (e.g. the same object)
-    *view_offset = descr0->allocator != descr1->allocator;
+    if (descr0->allocator == descr1->allocator) {
+        *view_offset = 0;
+    };
 
     return NPY_NO_CASTING;
 }

numpy/_core/src/umath/ufunc_object.c

@@ -62,6 +62,7 @@
 #include "legacy_array_method.h"
 #include "abstractdtypes.h"
 #include "mapping.h"
+#include "multiarraymodule.h"
 
 /* TODO: Only for `NpyIter_GetTransferFlags` until it is public */
 #define NPY_ITERATOR_IMPLEMENTATION_CODE
@@ -789,9 +790,9 @@ check_for_trivial_loop(PyArrayMethodObject *ufuncimpl,
 
         if (dtypes[i] != PyArray_DESCR(op[i])) {
             npy_intp view_offset;
-            NPY_CASTING safety = PyArray_GetCastInfo(
-                    PyArray_DESCR(op[i]), dtypes[i], NULL, &view_offset);
-            if (safety < 0 && PyErr_Occurred()) {
+            npy_intp is_safe = PyArray_SafeCast(
+                    PyArray_DESCR(op[i]), dtypes[i], &view_offset, casting, 0);
+            if (is_safe < 0 && PyErr_Occurred()) {
                 /* A proper error during a cast check, should be rare */
                 return -1;
             }
@@ -806,8 +807,8 @@ check_for_trivial_loop(PyArrayMethodObject *ufuncimpl,
                  * can  force cast to bool)
                  */
             }
-            else if (PyArray_MinCastSafety(safety, casting) != casting) {
-                return 0;  /* the cast is not safe enough */
+            else if (is_safe != 1) {
+                return 0;  /* there was a cast error or cast is not safe enough */
             }
         }
         if (must_copy) {