STY: Small style fixups for never-copy changes

Yes, these may be slightly biased towards my own opinions.

Author: seberg

numpy/core/include/numpy/ndarraytypes.h

@@ -450,9 +450,9 @@ typedef struct {
 } PyArray_Dims;
 
 typedef enum {
-        NPY_COPY_IF_NEEDED, 
-        NPY_COPY_ALWAYS, 
-        NPY_COPY_NEVER
+        NPY_COPY_IF_NEEDED = 0,
+        NPY_COPY_ALWAYS = 1,
+        NPY_COPY_NEVER = 2,
 } _PyArray_CopyMode;
 
 typedef struct {

numpy/core/src/multiarray/conversion_utils.c

@@ -171,30 +171,30 @@ PyArray_CopyConverter(PyObject *obj, _PyArray_CopyMode *copymode) {
         return NPY_FAIL;
     }
 
-    int int_copymode = -1;
+    int int_copymode;
     PyObject* numpy_CopyMode = NULL;
     npy_cache_import("numpy", "_CopyMode", &numpy_CopyMode);
 
-    if (numpy_CopyMode != NULL && PyObject_Type(obj) == numpy_CopyMode) {
+    if (numpy_CopyMode != NULL && (PyObject *)Py_TYPE(obj) == numpy_CopyMode) {
         PyObject* mode_value = PyObject_GetAttrString(obj, "value");
         if (mode_value == NULL) {
             return NPY_FAIL;
         }
 
-        int_copymode = PyLong_AsLong(mode_value);
+        int_copymode = (int)PyLong_AsLong(mode_value);
         if (error_converting(int_copymode)) {
             return NPY_FAIL;
         }
     }
     else {
         npy_bool bool_copymode;
-        if( !PyArray_BoolConverter(obj, &bool_copymode) ) {
+        if (!PyArray_BoolConverter(obj, &bool_copymode)) {
             return NPY_FAIL;
         }
-        int_copymode = (int) bool_copymode;
+        int_copymode = (int)bool_copymode;
     }
 
-    *copymode = (_PyArray_CopyMode) int_copymode;
+    *copymode = (_PyArray_CopyMode)int_copymode;
     return NPY_SUCCEED;
 }
 

numpy/core/src/multiarray/ctors.c

@@ -1879,13 +1879,12 @@ PyArray_CheckFromAny(PyObject *op, PyArray_Descr *descr, int min_depth,
         return NULL;
     }
 
-    if ((requires & NPY_ARRAY_ELEMENTSTRIDES) &&
-        !PyArray_ElementStrides(obj)) {
+    if ((requires & NPY_ARRAY_ELEMENTSTRIDES)
+            && !PyArray_ElementStrides(obj)) {
         PyObject *ret;
         if (requires & NPY_ARRAY_ENSURENOCOPY) {
             PyErr_SetString(PyExc_ValueError,
-                            "Unable to avoid copy "
-                            "while creating a new array.");
+                    "Unable to avoid copy while creating a new array.");
             return NULL;
         }
         ret = PyArray_NewCopy((PyArrayObject *)obj, NPY_ANYORDER);

numpy/core/src/multiarray/methods.c

@@ -875,10 +875,9 @@ array_astype(PyArrayObject *self,
         return (PyObject *)self;
     }
 
-    if( forcecopy == NPY_COPY_NEVER ) {
+    if (forcecopy == NPY_COPY_NEVER) {
         PyErr_SetString(PyExc_ValueError,
-                        "Unable to avoid copy while casting in "
-                        "never copy mode.");
+                "Unable to avoid copy while casting in never copy mode.");
         Py_DECREF(dtype);
         return NULL;
     }

numpy/core/src/multiarray/multiarraymodule.c

@@ -1579,16 +1579,15 @@ _array_fromobject_generic(
     if (PyArray_CheckExact(op) || (subok && PyArray_Check(op))) {
         oparr = (PyArrayObject *)op;
         if (type == NULL) {
-            if ((copy == NPY_COPY_IF_NEEDED || copy == NPY_COPY_NEVER) && 
-                STRIDING_OK(oparr, order)) {
+            if (copy != NPY_COPY_ALWAYS && STRIDING_OK(oparr, order)) {
                 ret = oparr;
                 Py_INCREF(ret);
                 goto finish;
             }
             else {
-                if( copy == NPY_COPY_NEVER ) {
+                if (copy == NPY_COPY_NEVER) {
                     PyErr_SetString(PyExc_ValueError,
-                                    "Unable to avoid copy while creating a new array.");
+                            "Unable to avoid copy while creating a new array.");
                     return NULL;
                 }
                 ret = (PyArrayObject *)PyArray_NewCopy(oparr, order);
@@ -1598,16 +1597,15 @@ _array_fromobject_generic(
         /* One more chance */
         oldtype = PyArray_DESCR(oparr);
         if (PyArray_EquivTypes(oldtype, type)) {
-            if ((copy == NPY_COPY_IF_NEEDED || copy == NPY_COPY_NEVER) && 
-                STRIDING_OK(oparr, order)) {
+            if (copy != NPY_COPY_ALWAYS && STRIDING_OK(oparr, order)) {
                 Py_INCREF(op);
                 ret = oparr;
                 goto finish;
             }
             else {
-                if( copy == NPY_COPY_NEVER ) {
+                if (copy == NPY_COPY_NEVER) {
                     PyErr_SetString(PyExc_ValueError,
-                                    "Unable to avoid copy while creating a new array.");
+                            "Unable to avoid copy while creating a new array.");
                     return NULL;
                 }
                 ret = (PyArrayObject *)PyArray_NewCopy(oparr, order);