STY: core: Improve formating of ParseTuple argument lists

Now in methods.c each argument gets its own line, so its easier to validate.

1 files changed, 105 insertions, 119 deletions

diff --git a/numpy/core/src/multiarray/methods.c b/numpy/core/src/multiarray/methods.c
index 9173bb0a6..e524c9e35 100644
--- a/numpy/core/src/multiarray/methods.c
+++ b/numpy/core/src/multiarray/methods.c
@@ -57,12 +57,10 @@ array_take(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"indices", "axis", "out", "mode", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&O&O&", kwlist,
-                                     &indices, PyArray_AxisConverter,
-                                     &dimension,
-                                     PyArray_OutputConverter,
-                                     &out,
-                                     PyArray_ClipmodeConverter,
-                                     &mode))
+                                     &indices,
+                                     PyArray_AxisConverter, &dimension,
+                                     PyArray_OutputConverter, &out,
+                                     PyArray_ClipmodeConverter, &mode))
         return NULL;
 
     return _ARET(PyArray_TakeFrom(self, indices, dimension, out, mode));
@@ -90,9 +88,9 @@ array_put(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"indices", "values", "mode", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O&", kwlist,
-                                     &indices, &values,
-                                     PyArray_ClipmodeConverter,
-                                     &mode))
+                                     &indices,
+                                     &values,
+                                     PyArray_ClipmodeConverter, &mode))
         return NULL;
     return PyArray_PutTo(self, values, indices, mode);
 }
@@ -203,10 +201,8 @@ array_argmax(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis,
-                                     PyArray_OutputConverter,
-                                     &out))
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_OutputConverter, &out))
         return NULL;
 
     return _ARET(PyArray_ArgMax(self, axis, out));
@@ -220,10 +216,8 @@ array_argmin(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis,
-                                     PyArray_OutputConverter,
-                                     &out))
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_OutputConverter, &out))
         return NULL;
 
     return _ARET(PyArray_ArgMin(self, axis, out));
@@ -237,10 +231,8 @@ array_max(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis,
-                                     PyArray_OutputConverter,
-                                     &out))
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_OutputConverter, &out))
         return NULL;
 
     return PyArray_Max(self, axis, out);
@@ -254,10 +246,8 @@ array_ptp(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis,
-                                     PyArray_OutputConverter,
-                                     &out))
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_OutputConverter, &out))
         return NULL;
 
     return PyArray_Ptp(self, axis, out);
@@ -272,10 +262,8 @@ array_min(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis,
-                                     PyArray_OutputConverter,
-                                     &out))
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_OutputConverter, &out))
         return NULL;
 
     return PyArray_Min(self, axis, out);
@@ -335,8 +323,8 @@ array_getfield(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"dtype", "offset", 0};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|i", kwlist,
-                                     PyArray_DescrConverter,
-                                     &dtype, &offset)) {
+                                     PyArray_DescrConverter, &dtype,
+                                     &offset)) {
         Py_XDECREF(dtype);
         return NULL;
     }
@@ -388,8 +376,9 @@ array_setfield(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"value", "dtype", "offset", 0};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&|i", kwlist,
-                                     &value, PyArray_DescrConverter,
-                                     &dtype, &offset)) {
+                                     &value,
+                                     PyArray_DescrConverter, &dtype,
+                                     &offset)) {
         Py_XDECREF(dtype);
         return NULL;
     }
@@ -459,7 +448,8 @@ array_byteswap(PyArrayObject *self, PyObject *args)
 {
     Bool inplace = FALSE;
 
-    if (!PyArg_ParseTuple(args, "|O&", PyArray_BoolConverter, &inplace)) {
+    if (!PyArg_ParseTuple(args, "|O&",
+                            PyArray_BoolConverter, &inplace)) {
         return NULL;
     }
     return PyArray_Byteswap(self, inplace);
@@ -482,8 +472,7 @@ array_tostring(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"order", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&", kwlist,
-                                     PyArray_OrderConverter,
-                                     &order)) {
+                                     PyArray_OrderConverter, &order)) {
         return NULL;
     }
     return PyArray_ToString(self, order);
@@ -504,7 +493,9 @@ array_tofile(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"file", "sep", "format", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|ss", kwlist,
-                                     &file, &sep, &format)) {
+                                     &file,
+                                     &sep,
+                                     &format)) {
         return NULL;
     }
 
@@ -875,8 +866,8 @@ array_getarray(PyArrayObject *self, PyObject *args)
     PyArray_Descr *newtype = NULL;
     PyObject *ret;
 
-    if (!PyArg_ParseTuple(args, "|O&", PyArray_DescrConverter,
-                          &newtype)) {
+    if (!PyArg_ParseTuple(args, "|O&",
+                            PyArray_DescrConverter, &newtype)) {
         Py_XDECREF(newtype);
         return NULL;
     }
@@ -924,15 +915,15 @@ array_getarray(PyArrayObject *self, PyObject *args)
 static PyObject *
 array_copy(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-    PyArray_ORDER fortran=PyArray_CORDER;
+    PyArray_ORDER order=PyArray_CORDER;
     static char *kwlist[] = {"order", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&", kwlist,
-                            PyArray_OrderConverter, &fortran)) {
+                            PyArray_OrderConverter, &order)) {
         return NULL;
     }
 
-    return PyArray_NewCopy(self, fortran);
+    return PyArray_NewCopy(self, order);
 }
 
 #include <stdio.h>
@@ -986,8 +977,8 @@ array_repeat(PyArrayObject *self, PyObject *args, PyObject *kwds) {
     static char *kwlist[] = {"repeats", "axis", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&", kwlist,
-                                     &repeats, PyArray_AxisConverter,
-                                     &axis)) {
+                                     &repeats,
+                                     PyArray_AxisConverter, &axis)) {
         return NULL;
     }
     return _ARET(PyArray_Repeat(self, repeats, axis));
@@ -1025,15 +1016,16 @@ array_sort(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
     int axis=-1;
     int val;
-    PyArray_SORTKIND which = PyArray_QUICKSORT;
+    PyArray_SORTKIND sortkind = PyArray_QUICKSORT;
     PyObject *order = NULL;
     PyArray_Descr *saved = NULL;
     PyArray_Descr *newd;
     static char *kwlist[] = {"axis", "kind", "order", NULL};
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO&O", kwlist, &axis,
-                                     PyArray_SortkindConverter, &which,
-                                     &order)) {
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO&O", kwlist,
+                                    &axis,
+                                    PyArray_SortkindConverter, &sortkind,
+                                    &order)) {
         return NULL;
     }
     if (order == Py_None) {
@@ -1063,7 +1055,7 @@ array_sort(PyArrayObject *self, PyObject *args, PyObject *kwds)
         self->descr = newd;
     }
 
-    val = PyArray_Sort(self, axis, which);
+    val = PyArray_Sort(self, axis, sortkind);
     if (order != NULL) {
         Py_XDECREF(self->descr);
         self->descr = saved;
@@ -1079,14 +1071,14 @@ static PyObject *
 array_argsort(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
     int axis = -1;
-    PyArray_SORTKIND which = PyArray_QUICKSORT;
+    PyArray_SORTKIND sortkind = PyArray_QUICKSORT;
     PyObject *order = NULL, *res;
     PyArray_Descr *newd, *saved=NULL;
     static char *kwlist[] = {"axis", "kind", "order", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O", kwlist,
                                      PyArray_AxisConverter, &axis,
-                                     PyArray_SortkindConverter, &which,
+                                     PyArray_SortkindConverter, &sortkind,
                                      &order)) {
         return NULL;
     }
@@ -1117,7 +1109,7 @@ array_argsort(PyArrayObject *self, PyObject *args, PyObject *kwds)
         self->descr = newd;
     }
 
-    res = PyArray_ArgSort(self, axis, which);
+    res = PyArray_ArgSort(self, axis, sortkind);
     if (order != NULL) {
         Py_XDECREF(self->descr);
         self->descr = saved;
@@ -1365,14 +1357,19 @@ array_setstate(PyArrayObject *self, PyObject *args)
     /* This will free any memory associated with a and
        use the string in setstate as the (writeable) memory.
     */
-    if (!PyArg_ParseTuple(args, "(iO!O!iO)", &version, &PyTuple_Type,
-                          &shape, &PyArrayDescr_Type, &typecode,
-                          &fortran, &rawdata)) {
+    if (!PyArg_ParseTuple(args, "(iO!O!iO)",
+                            &version,
+                            &PyTuple_Type, &shape,
+                            &PyArrayDescr_Type, &typecode,
+                            &fortran,
+                            &rawdata)) {
         PyErr_Clear();
         version = 0;
-        if (!PyArg_ParseTuple(args, "(O!O!iO)", &PyTuple_Type,
-                              &shape, &PyArrayDescr_Type, &typecode,
-                              &fortran, &rawdata)) {
+        if (!PyArg_ParseTuple(args, "(O!O!iO)",
+                            &PyTuple_Type, &shape,
+                            &PyArrayDescr_Type, &typecode,
+                            &fortran,
+                            &rawdata)) {
             return NULL;
         }
     }
@@ -1685,11 +1682,9 @@ array_mean(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis, PyArray_DescrConverter2,
-                                     &dtype,
-                                     PyArray_OutputConverter,
-                                     &out)) {
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_DescrConverter2, &dtype,
+                                     PyArray_OutputConverter, &out)) {
         Py_XDECREF(dtype);
         return NULL;
     }
@@ -1709,11 +1704,9 @@ array_sum(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis, PyArray_DescrConverter2,
-                                     &dtype,
-                                     PyArray_OutputConverter,
-                                     &out)) {
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_DescrConverter2, &dtype,
+                                     PyArray_OutputConverter, &out)) {
         Py_XDECREF(dtype);
         return NULL;
     }
@@ -1734,11 +1727,9 @@ array_cumsum(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis, PyArray_DescrConverter2,
-                                     &dtype,
-                                     PyArray_OutputConverter,
-                                     &out)) {
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_DescrConverter2, &dtype,
+                                     PyArray_OutputConverter, &out)) {
         Py_XDECREF(dtype);
         return NULL;
     }
@@ -1758,11 +1749,9 @@ array_prod(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis, PyArray_DescrConverter2,
-                                     &dtype,
-                                     PyArray_OutputConverter,
-                                     &out)) {
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_DescrConverter2, &dtype,
+                                     PyArray_OutputConverter, &out)) {
         Py_XDECREF(dtype);
         return NULL;
     }
@@ -1782,11 +1771,9 @@ array_cumprod(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "dtype", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis, PyArray_DescrConverter2,
-                                     &dtype,
-                                     PyArray_OutputConverter,
-                                     &out)) {
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_DescrConverter2, &dtype,
+                                     PyArray_OutputConverter, &out)) {
         Py_XDECREF(dtype);
         return NULL;
     }
@@ -1828,10 +1815,8 @@ array_any(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis,
-                                     PyArray_OutputConverter,
-                                     &out))
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_OutputConverter, &out))
         return NULL;
 
     return PyArray_Any(self, axis, out);
@@ -1846,10 +1831,8 @@ array_all(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis,
-                                     PyArray_OutputConverter,
-                                     &out))
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_OutputConverter, &out))
         return NULL;
 
     return PyArray_All(self, axis, out);
@@ -1867,11 +1850,10 @@ array_stddev(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "dtype", "out", "ddof", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&i", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis, PyArray_DescrConverter2,
-                                     &dtype,
-                                     PyArray_OutputConverter,
-                                     &out, &ddof)) {
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_DescrConverter2, &dtype,
+                                     PyArray_OutputConverter, &out,
+                                     &ddof)) {
         Py_XDECREF(dtype);
         return NULL;
     }
@@ -1893,11 +1875,10 @@ array_variance(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"axis", "dtype", "out", "ddof", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&O&O&i", kwlist,
-                                     PyArray_AxisConverter,
-                                     &axis, PyArray_DescrConverter2,
-                                     &dtype,
-                                     PyArray_OutputConverter,
-                                     &out, &ddof)) {
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_DescrConverter2, &dtype,
+                                     PyArray_OutputConverter, &out,
+                                     &ddof)) {
         Py_XDECREF(dtype);
         return NULL;
     }
@@ -1917,10 +1898,9 @@ array_compress(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"condition", "axis", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&O&", kwlist,
-                                     &condition, PyArray_AxisConverter,
-                                     &axis,
-                                     PyArray_OutputConverter,
-                                     &out)) {
+                                     &condition,
+                                     PyArray_AxisConverter, &axis,
+                                     PyArray_OutputConverter, &out)) {
         return NULL;
     }
     return _ARET(PyArray_Compress(self, condition, axis, out));
@@ -1947,7 +1927,9 @@ array_trace(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"offset", "axis1", "axis2", "dtype", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiiO&O&", kwlist,
-                                     &offset, &axis1, &axis2,
+                                     &offset,
+                                     &axis1,
+                                     &axis2,
                                      PyArray_DescrConverter2, &dtype,
                                      PyArray_OutputConverter, &out)) {
         Py_XDECREF(dtype);
@@ -1970,9 +1952,9 @@ array_clip(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"min", "max", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO&", kwlist,
-                                     &min, &max,
-                                     PyArray_OutputConverter,
-                                     &out)) {
+                                     &min,
+                                     &max,
+                                     PyArray_OutputConverter, &out)) {
         return NULL;
     }
     if (max == NULL && min == NULL) {
@@ -2004,7 +1986,9 @@ array_diagonal(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"offset", "axis1", "axis2", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,
-                                     &offset, &axis1, &axis2)) {
+                                     &offset,
+                                     &axis1,
+                                     &axis2)) {
         return NULL;
     }
     return _ARET(PyArray_Diagonal(self, offset, axis1, axis2));
@@ -2014,28 +1998,28 @@ array_diagonal(PyArrayObject *self, PyObject *args, PyObject *kwds)
 static PyObject *
 array_flatten(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-    PyArray_ORDER fortran = PyArray_CORDER;
+    PyArray_ORDER order = PyArray_CORDER;
     static char *kwlist[] = {"order", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&", kwlist,
-                            PyArray_OrderConverter, &fortran)) {
+                            PyArray_OrderConverter, &order)) {
         return NULL;
     }
-    return PyArray_Flatten(self, fortran);
+    return PyArray_Flatten(self, order);
 }
 
 
 static PyObject *
 array_ravel(PyArrayObject *self, PyObject *args, PyObject *kwds)
 {
-    PyArray_ORDER fortran = PyArray_CORDER;
+    PyArray_ORDER order = PyArray_CORDER;
     static char *kwlist[] = {"order", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&", kwlist,
-                            PyArray_OrderConverter, &fortran)) {
+                            PyArray_OrderConverter, &order)) {
         return NULL;
     }
-    return PyArray_Ravel(self, fortran);
+    return PyArray_Ravel(self, order);
 }
 
 
@@ -2047,8 +2031,8 @@ array_round(PyArrayObject *self, PyObject *args, PyObject *kwds)
     static char *kwlist[] = {"decimals", "out", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO&", kwlist,
-                                     &decimals, PyArray_OutputConverter,
-                                     &out)) {
+                                     &decimals,
+                                     PyArray_OutputConverter, &out)) {
         return NULL;
     }
     return _ARET(PyArray_Round(self, decimals, out));
@@ -2066,7 +2050,9 @@ array_setflags(PyArrayObject *self, PyObject *args, PyObject *kwds)
     int flagback = self->flags;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist,
-                                     &write, &align, &uic))
+                                     &write,
+                                     &align,
+                                     &uic))
         return NULL;
 
     if (align != Py_None) {