Merge pull request numpy#2812 from dwf/deprecate_scalar_float

Deprecate non-integer scalar indices and slice parameters

Author: charris

numpy/core/src/multiarray/iterators.c

@@ -70,6 +70,12 @@ parse_index_entry(PyObject *op, npy_intp *step_size,
         }
         *n_steps = SINGLE_INDEX;
         *step_size = 0;
+        if (!PyIndex_Check_Or_Unsupported(op)) {
+            if (DEPRECATE("non-integer scalar index. In a future numpy "
+                          "release, this will raise an error.") < 0) {
+                goto fail;
+            }
+        }
         if (check_index) {
             if (check_and_adjust_index(&i, max, axis) < 0) {
             goto fail;
@@ -223,8 +229,32 @@ slice_coerce_index(PyObject *o, npy_intp *v)
     return 1;
 }
 
-/* This is basically PySlice_GetIndicesEx, but with our coercion
- * of indices to integers (plus, that function is new in Python 2.3) */
+/*
+ * Issue a DeprecationWarning for slice parameters that do not pass a
+ * PyIndex_Check, returning -1 if an error occurs.
+ *
+ * N.B. This function, like slice_GetIndices, will be obsolete once
+ * non-integer slice parameters becomes an error rather than a warning.
+ */
+static NPY_INLINE int
+_validate_slice_parameter(PyObject *o)
+{
+    if (!PyIndex_Check_Or_Unsupported(o)) {
+        if (DEPRECATE("non-integer slice parameter. In a future numpy "
+                      "release, this will raise an error.") < 0) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+/*
+ * This is basically PySlice_GetIndicesEx, but with our coercion
+ * of indices to integers (plus, that function is new in Python 2.3)
+ *
+ * N.B. The coercion to integers is deprecated; once the DeprecationWarning
+ * is changed to an error, it would seem that this is obsolete.
+ */
 NPY_NO_EXPORT int
 slice_GetIndices(PySliceObject *r, npy_intp length,
                  npy_intp *start, npy_intp *stop, npy_intp *step,
@@ -236,6 +266,9 @@ slice_GetIndices(PySliceObject *r, npy_intp length,
         *step = 1;
     }
     else {
+        if (_validate_slice_parameter(r->step) < 0) {
+            return -1;
+        }
         if (!slice_coerce_index(r->step, step)) {
             return -1;
         }
@@ -251,6 +284,9 @@ slice_GetIndices(PySliceObject *r, npy_intp length,
         *start = *step < 0 ? length-1 : 0;
     }
     else {
+        if (_validate_slice_parameter(r->start) < 0) {
+            return -1;
+        }
         if (!slice_coerce_index(r->start, start)) {
             return -1;
         }
@@ -269,6 +305,9 @@ slice_GetIndices(PySliceObject *r, npy_intp length,
         *stop = defstop;
     }
     else {
+        if (_validate_slice_parameter(r->stop) < 0) {
+            return -1;
+        }
         if (!slice_coerce_index(r->stop, stop)) {
             return -1;
         }

numpy/core/src/multiarray/mapping.c

@@ -1129,10 +1129,19 @@ array_ass_sub_simple(PyArrayObject *self, PyObject *ind, PyObject *op)
     return ret;
 }
 
+/* Check if ind is a tuple and if it has as many elements as arr has axes. */
+static NPY_INLINE int
+_is_full_index(PyObject *ind, PyArrayObject *arr)
+{
+    return PyTuple_Check(ind) && (PyTuple_GET_SIZE(ind) == PyArray_NDIM(arr));
+}
 
-/* return -1 if tuple-object seq is not a tuple of integers.
-   otherwise fill vals with converted integers
-*/
+/*
+ * Returns 0 if tuple-object seq is not a tuple of integers.
+ * If the return value is positive, vals will be filled with the elements
+ * from the tuple.
+ * Returns -1 on error.
+ */
 static int
 _tuple_of_integers(PyObject *seq, npy_intp *vals, int maxvals)
 {
@@ -1144,15 +1153,21 @@ _tuple_of_integers(PyObject *seq, npy_intp *vals, int maxvals)
         obj = PyTuple_GET_ITEM(seq, i);
         if ((PyArray_Check(obj) && PyArray_NDIM((PyArrayObject *)obj) > 0)
                 || PyList_Check(obj)) {
-            return -1;
+            return 0;
         }
         temp = PyArray_PyIntAsIntp(obj);
         if (error_converting(temp)) {
-            return -1;
+            return 0;
+        }
+        if (!PyIndex_Check_Or_Unsupported(obj)) {
+            if (DEPRECATE("non-integer scalar index. In a future numpy "
+                          "release, this will raise an error.") < 0) {
+                return -1;
+            }
         }
         vals[i] = temp;
     }
-    return 0;
+    return 1;
 }
 
 
@@ -1257,22 +1272,26 @@ array_ass_sub(PyArrayObject *self, PyObject *ind, PyObject *op)
     }
 
     /* Integer-tuple */
-    if (PyTuple_Check(ind) &&
-                (PyTuple_GET_SIZE(ind) == PyArray_NDIM(self)) &&
-                (_tuple_of_integers(ind, vals, PyArray_NDIM(self)) >= 0)) {
-        int idim, ndim = PyArray_NDIM(self);
-        npy_intp *shape = PyArray_DIMS(self);
-        npy_intp *strides = PyArray_STRIDES(self);
-        char *item = PyArray_DATA(self);
-
-        for (idim = 0; idim < ndim; idim++) {
-            npy_intp v = vals[idim];
-            if (check_and_adjust_index(&v, shape[idim], idim) < 0) {
-              return -1;
+    if (_is_full_index(ind, self)) {
+        ret = _tuple_of_integers(ind, vals, PyArray_NDIM(self));
+        /* In case an exception occurred (e.g. in PyErr_WarnEx) */
+        if (ret < 0) {
+            return -1;
+        }
+        else if (ret > 0) {
+            int idim, ndim = PyArray_NDIM(self);
+            npy_intp *shape = PyArray_DIMS(self);
+            npy_intp *strides = PyArray_STRIDES(self);
+            char *item = PyArray_DATA(self);
+            for (idim = 0; idim < ndim; idim++) {
+                npy_intp v = vals[idim];
+                if (check_and_adjust_index(&v, shape[idim], idim) < 0) {
+                  return -1;
+                }
+                item += v * strides[idim];
             }
-            item += v * strides[idim];
+            return PyArray_DESCR(self)->f->setitem(op, item, self);
         }
-        return PyArray_DESCR(self)->f->setitem(op, item, self);
     }
     PyErr_Clear();
 
@@ -1350,6 +1369,7 @@ array_subscript_nice(PyArrayObject *self, PyObject *op)
 {
 
     PyArrayObject *mp;
+    int ret;
     npy_intp vals[NPY_MAXDIMS];
 
     if (PyInt_Check(op) || PyArray_IsScalar(op, Integer) ||
@@ -1364,27 +1384,39 @@ array_subscript_nice(PyArrayObject *self, PyObject *op)
             return array_item_nice(self, (Py_ssize_t) value);
         }
     }
-    /* optimization for a tuple of integers */
-    if (PyArray_NDIM(self) > 1 &&
-                PyTuple_Check(op) &&
-                (PyTuple_GET_SIZE(op) == PyArray_NDIM(self)) &&
-                (_tuple_of_integers(op, vals, PyArray_NDIM(self)) >= 0)) {
-        int idim, ndim = PyArray_NDIM(self);
-        npy_intp *shape = PyArray_DIMS(self);
-        npy_intp *strides = PyArray_STRIDES(self);
-        char *item = PyArray_DATA(self);
-
-        for (idim = 0; idim < ndim; idim++) {
-            npy_intp v = vals[idim];
-            if (check_and_adjust_index(&v, shape[idim], idim) < 0) { 
-              return NULL;
+    /*
+     * Optimization for a tuple of integers that is the same size as the
+     * array's dimension.
+     */
+    if (PyArray_NDIM(self) > 1 && _is_full_index(op,  self)) {
+        ret = _tuple_of_integers(op, vals, PyArray_NDIM(self));
+        /* In case an exception occurred (e.g. in PyErr_WarnEx) */
+        if (ret < 0) {
+            return NULL;
+        }
+        else if (ret > 0) {
+            int idim, ndim = PyArray_NDIM(self);
+            npy_intp *shape = PyArray_DIMS(self);
+            npy_intp *strides = PyArray_STRIDES(self);
+            char *item = PyArray_DATA(self);
+            for (idim = 0; idim < ndim; idim++) {
+                npy_intp v = vals[idim];
+                if (check_and_adjust_index(&v, shape[idim], idim) < 0) {
+                  return NULL;
+                }
+                item += v * strides[idim];
             }
-            item += v * strides[idim];
+            return PyArray_Scalar(item, PyArray_DESCR(self), (PyObject *)self);
         }
-        return PyArray_Scalar(item, PyArray_DESCR(self), (PyObject *)self);
     }
     PyErr_Clear();
-
+    if ((PyNumber_Check(op) || PyArray_IsScalar(op, Number)) &&
+            !PyIndex_Check_Or_Unsupported(op)) {
+        if (DEPRECATE("non-integer scalar index. In a future numpy "
+                      "release, this will raise an error.") < 0) {
+            return NULL;
+        }
+    }
     mp = (PyArrayObject *)array_subscript(self, op);
     /*
      * mp could be a scalar if op is not an Int, Scalar, Long or other Index

numpy/core/src/private/npy_pycompat.h

@@ -19,6 +19,10 @@
 #if (PY_VERSION_HEX < 0x02050000)
 #undef PyIndex_Check
 #define PyIndex_Check(o)     0
+#undef PyIndex_Check_Or_Unsupported
+#define PyIndex_Check_Or_Unsupported(o) 1
+#else
+#define PyIndex_Check_Or_Unsupported(o) PyIndex_Check(o)
 #endif
 
 #endif /* _NPY_COMPAT_H_ */