Enable NUMPY_DISLIKE_SCALARS=1

I don't believe in this (I mean as an option, I suppose who cares,
but that isn't actually useful if you can never transition, IMO).

But, it should be at least tried a bit, so...

Author: seberg

numpy/_core/arrayprint.py

@@ -851,7 +851,7 @@ def recurser(index, hanging_indent, curr_width):
         axes_left = a.ndim - axis
 
         if axes_left == 0:
-            return format_function(a[index])
+            return format_function(a[index + (...,)].to_scalar())
 
         # when recursing, add a space to align with the [ added, and reduce the
         # length of the line by 1
@@ -1709,7 +1709,7 @@ def _array_str_implementation(
         # obtain a scalar and call str on it, avoiding problems for subclasses
         # for which indexing with () returns a 0d instead of a scalar by using
         # ndarray's getindex. Also guard against recursive 0d object arrays.
-        return _guarded_repr_or_str(np.ndarray.__getitem__(a, ()))
+        return _guarded_repr_or_str(np.ndarray.to_scalar(a))
 
     return array2string(a, max_line_width, precision, suppress_small, ' ', "")
 

numpy/_core/src/multiarray/arraywrap.c

@@ -14,6 +14,7 @@
 
 #include "arraywrap.h"
 #include "npy_static_data.h"
+#include "multiarraymodule.h"
 
 /*
  * Find the array wrap or array prepare method that applies to the inputs.
@@ -139,6 +140,8 @@ npy_apply_wrap(
     PyArrayObject *arr = NULL;
     PyObject *err_type, *err_value, *traceback;
 
+    return_scalar = (return_scalar && !npy_thread_unsafe_state.dislike_scalars);
+
     /* If provided, we prefer the actual out objects wrap: */
     if (original_out != NULL && original_out != Py_None) {
         /*

numpy/_core/src/multiarray/mapping.c

@@ -29,6 +29,7 @@
 /* TODO: Only for `NpyIter_GetTransferFlags` until it is public */
 #define NPY_ITERATOR_IMPLEMENTATION_CODE
 #include "nditer_impl.h"
+#include "multiarraymodule.h"
 
 #include "umathmodule.h"
 
@@ -1302,7 +1303,7 @@ array_item_asarray(PyArrayObject *self, npy_intp i)
 NPY_NO_EXPORT PyObject *
 array_item(PyArrayObject *self, Py_ssize_t i)
 {
-    if (PyArray_NDIM(self) == 1) {
+    if (PyArray_NDIM(self) == 1 && !npy_thread_unsafe_state.dislike_scalars) {
         char *item;
         npy_index_info index;
 
@@ -1485,7 +1486,7 @@ array_subscript(PyArrayObject *self, PyObject *op)
     }
 
     /* Full integer index */
-    else if (index_type == HAS_INTEGER) {
+    else if (index_type == HAS_INTEGER && !npy_thread_unsafe_state.dislike_scalars) {
         char *item;
         if (get_item_pointer(self, &item, indices, index_num) < 0) {
             goto finish;

numpy/_core/src/multiarray/methods.c

@@ -2797,6 +2797,27 @@ array_class_getitem(PyObject *cls, PyObject *args)
     return Py_GenericAlias(cls, args);
 }
 
+static PyObject *
+array_to_scalar(PyArrayObject *mp, PyObject *NPY_UNUSED(args))
+{
+    /* TODO, just a silly copy of PyArray_Result, as I disabled that! */
+    Py_INCREF(mp);
+    if (!PyArray_Check(mp)) {
+        return (PyObject *)mp;
+    }
+    if (PyArray_NDIM(mp) == 0) {
+        PyObject *ret;
+        ret = PyArray_ToScalar(PyArray_DATA(mp), mp);
+        Py_DECREF(mp);
+        return ret;
+    }
+    else {
+        return (PyObject *)mp;
+    }
+}
+
+
+
 NPY_NO_EXPORT PyMethodDef array_methods[] = {
 
     /* for subtypes */
@@ -3025,6 +3046,9 @@ NPY_NO_EXPORT PyMethodDef array_methods[] = {
     {"to_device",
         (PyCFunction)array_to_device,
         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"to_scalar",
+        (PyCFunction)array_to_scalar,
+        METH_NOARGS, NULL},
 
     {NULL, NULL, 0, NULL}           /* sentinel */
 };

numpy/_core/src/multiarray/multiarraymodule.c

@@ -4770,6 +4770,14 @@ initialize_thread_unsafe_state(void) {
         npy_thread_unsafe_state.warn_if_no_mem_policy = 0;
     }
 
+    env = getenv("NUMPY_DISLIKE_SCALARS");
+    if ((env != NULL) && (strncmp(env, "1", 1) == 0)) {
+        npy_thread_unsafe_state.dislike_scalars = 1;
+    }
+    else {
+        npy_thread_unsafe_state.dislike_scalars = 0;
+    }
+
     return 0;
 }
 

numpy/_core/src/multiarray/multiarraymodule.h

@@ -76,6 +76,7 @@ typedef struct npy_thread_unsafe_state_struct {
      * if there is no memory policy set
      */
     int warn_if_no_mem_policy;
+    int dislike_scalars;
 
 } npy_thread_unsafe_state_struct;
 

numpy/_core/src/multiarray/scalarapi.c

@@ -18,6 +18,7 @@
 #include "ctors.h"
 #include "descriptor.h"
 #include "dtypemeta.h"
+#include "multiarraymodule.h"
 #include "scalartypes.h"
 
 #include "common.h"
@@ -631,7 +632,9 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
 NPY_NO_EXPORT PyObject *
 PyArray_Return(PyArrayObject *mp)
 {
-
+    if (npy_thread_unsafe_state.dislike_scalars) {
+        return (PyObject *)mp;
+    }
     if (mp == NULL) {
         return NULL;
     }

numpy/_core/src/multiarray/scalartypes.c.src

@@ -2591,6 +2591,12 @@ integer_is_integer(PyObject *self, PyObject *NPY_UNUSED(args)) {
     Py_RETURN_TRUE;
 }
 
+static PyObject *
+gentype_to_scalar(PyObject *self, PyObject *NPY_UNUSED(args)) {
+    Py_INCREF(self);
+    return self;
+}
+
 /*
  * need to fill in doc-strings for these methods on import -- copy from
  * array docstrings
@@ -2789,6 +2795,9 @@ static PyMethodDef gentype_methods[] = {
     {"to_device",
         (PyCFunction)array_to_device,
         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"to_scalar",
+        (PyCFunction)gentype_to_scalar,
+        METH_NOARGS, NULL},
 
     {NULL, NULL, 0, NULL} /* sentinel */
 };

numpy/_core/tests/test_array_coercion.py

@@ -84,6 +84,9 @@ def __init__(self, a):
 def scalar_instances(times=True, extended_precision=True, user_dtype=True):
     # Hard-coded list of scalar instances.
     # Floats:
+    if type(np.array(1)[()]) is np.ndarray:
+        return  # whooops doesn't work at all
+
     yield param(np.sqrt(np.float16(5)), id="float16")
     yield param(np.sqrt(np.float32(5)), id="float32")
     yield param(np.sqrt(np.float64(5)), id="float64")

numpy/_core/tests/test_nditer.py

@@ -1059,7 +1059,7 @@ def test_iter_object_arrays_basic():
         assert_equal(sys.getrefcount(obj), rc)
 
     i = nditer(a, ['refs_ok'], ['readonly'])
-    vals = [x_[()] for x_ in i]
+    vals = [x_.to_scalar() for x_ in i]
     assert_equal(np.array(vals, dtype='O'), a)
     vals, i, x = [None] * 3
     if HAS_REFCOUNT:
@@ -1068,7 +1068,7 @@ def test_iter_object_arrays_basic():
     i = nditer(a.reshape(2, 2).T, ['refs_ok', 'buffered'],
                         ['readonly'], order='C')
     assert_(i.iterationneedsapi)
-    vals = [x_[()] for x_ in i]
+    vals = [x_.to_scalar() for x_ in i]
     assert_equal(np.array(vals, dtype='O'), a.reshape(2, 2).ravel(order='F'))
     vals, i, x = [None] * 3
     if HAS_REFCOUNT:
@@ -1120,7 +1120,7 @@ def test_iter_object_arrays_conversions():
     i = nditer(a, ['refs_ok', 'buffered'], ['readwrite'],
                     casting='unsafe', op_dtypes='O')
     with i:
-        ob = i[0][()]
+        ob = i[0, ...].to_scalar()
         if HAS_REFCOUNT:
             rc = sys.getrefcount(ob)
         for x in i:
@@ -1356,42 +1356,42 @@ def test_iter_copy():
     # Simple iterator
     i = nditer(a)
     j = i.copy()
-    assert_equal([x[()] for x in i], [x[()] for x in j])
+    assert_equal([x.to_scalar() for x in i], [x.to_scalar() for x in j])
 
     i.iterindex = 3
     j = i.copy()
-    assert_equal([x[()] for x in i], [x[()] for x in j])
+    assert_equal([x.to_scalar() for x in i], [x.to_scalar() for x in j])
 
     # Buffered iterator
     i = nditer(a, ['buffered', 'ranged'], order='F', buffersize=3)
     j = i.copy()
-    assert_equal([x[()] for x in i], [x[()] for x in j])
+    assert_equal([x.to_scalar() for x in i], [x.to_scalar() for x in j])
 
     i.iterindex = 3
     j = i.copy()
-    assert_equal([x[()] for x in i], [x[()] for x in j])
+    assert_equal([x.to_scalar() for x in i], [x.to_scalar() for x in j])
 
     i.iterrange = (3, 9)
     j = i.copy()
-    assert_equal([x[()] for x in i], [x[()] for x in j])
+    assert_equal([x.to_scalar() for x in i], [x.to_scalar() for x in j])
 
     i.iterrange = (2, 18)
     next(i)
     next(i)
     j = i.copy()
-    assert_equal([x[()] for x in i], [x[()] for x in j])
+    assert_equal([x.to_scalar() for x in i], [x.to_scalar() for x in j])
 
     # Casting iterator
     with nditer(a, ['buffered'], order='F', casting='unsafe',
                 op_dtypes='f8', buffersize=5) as i:
         j = i.copy()
-    assert_equal([x[()] for x in j], a.ravel(order='F'))
+    assert_equal([x.to_scalar() for x in j], a.ravel(order='F'))
 
     a = arange(24, dtype='<i4').reshape(2, 3, 4)
     with nditer(a, ['buffered'], order='F', casting='unsafe',
                 op_dtypes='>f8', buffersize=5) as i:
         j = i.copy()
-    assert_equal([x[()] for x in j], a.ravel(order='F'))
+    assert_equal([x.to_scalar() for x in j], a.ravel(order='F'))
 
 
 @pytest.mark.parametrize("dtype", np.typecodes["All"])
@@ -1757,20 +1757,20 @@ def test_iter_iterrange():
     i = nditer(a, ['ranged'], ['readonly'], order='F',
                 buffersize=buffersize)
     assert_equal(i.iterrange, (0, 24))
-    assert_equal([x[()] for x in i], a_fort)
+    assert_equal([x.to_scalar() for x in i], a_fort)
     for r in [(0, 24), (1, 2), (3, 24), (5, 5), (0, 20), (23, 24)]:
         i.iterrange = r
         assert_equal(i.iterrange, r)
-        assert_equal([x[()] for x in i], a_fort[r[0]:r[1]])
+        assert_equal([x.to_scalar() for x in i], a_fort[r[0]:r[1]])
 
     i = nditer(a, ['ranged', 'buffered'], ['readonly'], order='F',
                 op_dtypes='f8', buffersize=buffersize)
     assert_equal(i.iterrange, (0, 24))
-    assert_equal([x[()] for x in i], a_fort)
+    assert_equal([x.to_scalar() for x in i], a_fort)
     for r in [(0, 24), (1, 2), (3, 24), (5, 5), (0, 20), (23, 24)]:
         i.iterrange = r
         assert_equal(i.iterrange, r)
-        assert_equal([x[()] for x in i], a_fort[r[0]:r[1]])
+        assert_equal([x.to_scalar() for x in i], a_fort[r[0]:r[1]])
 
     def get_array(i):
         val = np.array([], dtype='f8')
@@ -1862,7 +1862,7 @@ def assign_iter(i):
         assert_equal(i[0], 0)
         i[1] = 1
         assert_equal(i[0:2], [0, 1])
-        assert_equal([[x[0][()], x[1][()]] for x in i], list(zip(range(6), [1] * 6)))
+        assert_equal([[x[0, ...].to_scalar(), x[1, ...].to_scalar()] for x in i], list(zip(range(6), [1] * 6)))
 
 def test_iter_buffered_cast_simple():
     # Test that buffering can handle a simple cast
@@ -2015,7 +2015,7 @@ def test_iter_buffered_cast_structured_type():
     i = nditer(a, ['buffered', 'refs_ok'], ['readonly'],
                     casting='unsafe',
                     op_dtypes='i4')
-    assert_equal([x_[()] for x_ in i], [5, 8])
+    assert_equal([x_.to_scalar() for x_ in i], [5, 8])
 
     # make sure multi-field struct type -> simple doesn't work
     sdt = [('a', 'f4'), ('b', 'i8'), ('d', 'O')]