PR#9: Fix FTBFS with Py3.8 - rpms/scipy

rpms / scipy

#9 Fix FTBFS with Py3.8

Merged 4 years ago by churchyard. Opened 4 years ago by dormouse.

rpms/ dormouse/scipy master into master

Marcel Plch • 4 years ago

180d901

file added

+589

		`@@ -0,0 +1,589 @@`
		`+ diff -ru scipy-1.2.1/scipy/odr/__odrpack.c scipy-1.2.1_patched/scipy/odr/__odrpack.c`
		`+ --- scipy-1.2.1/scipy/odr/__odrpack.c 2019-01-28 04:57:51.000000000 +0100`
		`+ +++ scipy-1.2.1_patched/scipy/odr/__odrpack.c 2019-06-06 16:11:32.947892754 +0200`
		`+ @@ -9,6 +9,8 @@`
		`+ *`
		`+ */`
		`+`
		`+ +#define PY_SSIZE_T_CLEAN`
		`+ +#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION`
		`+ #include "odrpack.h"`
		`+`
		`+`
		`+ @@ -44,7 +46,7 @@`
		`+ double fjacb, double fjacd, int *istop)`
		`+ {`
		`+ PyObject arg01, arglist;`
		`+ - PyObject *result;`
		`+ + PyObject *result = NULL;`
		`+ PyArrayObject *result_array = NULL;`
		`+ PyArrayObject *pyXplusD;`
		`+ void *beta_dst;`
		`+ @@ -57,14 +59,14 @@`
		`+ dim2[0] = *m;`
		`+ dim2[1] = *n;`
		`+ pyXplusD = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);`
		`+ - memcpy(pyXplusD->data, (void )xplusd, (m) * (n) sizeof(double));`
		`+ + memcpy(PyArray_DATA(pyXplusD), (void )xplusd, (m) * (n) sizeof(double));`
		`+ }`
		`+ else`
		`+ {`
		`+ npy_intp dim1[1];`
		`+ dim1[0] = *n;`
		`+ pyXplusD = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);`
		`+ - memcpy(pyXplusD->data, (void )xplusd, (n) * sizeof(double));`
		`+ + memcpy(PyArray_DATA(pyXplusD), (void )xplusd, (n) * sizeof(double));`
		`+ }`
		`+`
		`+ PyTuple_SetItem(arg01, 0, odr_global.pyBeta);`
		`+ @@ -84,7 +86,7 @@`
		`+ Py_DECREF(arg01);`
		`+ *istop = 0;`
		`+`
		`+ - beta_dst = ((PyArrayObject *) (odr_global.pyBeta))->data;`
		`+ + beta_dst = (PyArray_DATA((PyArrayObject *) odr_global.pyBeta));`
		`+ if (beta != beta_dst) {`
		`+ memcpy(beta_dst, (void )beta, (np) * sizeof(double));`
		`+ }`
		`+ @@ -121,7 +123,7 @@`
		`+ "Result from function call is not a proper array of floats.");`
		`+ }`
		`+`
		`+ - memcpy((void )f, result_array->data, (n) * (nq) sizeof(double));`
		`+ + memcpy((void )f, PyArray_DATA(result_array), (n) * (nq) sizeof(double));`
		`+ Py_DECREF(result_array);`
		`+ }`
		`+`
		`+ @@ -161,7 +163,7 @@`
		`+ {`
		`+ /* result_array should be rank-3 */`
		`+`
		`+ - if (result_array->nd != 3)`
		`+ + if (PyArray_NDIM(result_array) != 3)`
		`+ {`
		`+ Py_DECREF(result_array);`
		`+ PYERR2(odr_error, "Beta Jacobian is not rank-3");`
		`+ @@ -171,14 +173,14 @@`
		`+ {`
		`+ /* result_array should be rank-2 */`
		`+`
		`+ - if (result_array->nd != 2)`
		`+ + if (PyArray_NDIM(result_array) != 2)`
		`+ {`
		`+ Py_DECREF(result_array);`
		`+ PYERR2(odr_error, "Beta Jacobian is not rank-2");`
		`+ }`
		`+ }`
		`+`
		`+ - memcpy((void *)fjacb, result_array->data,`
		`+ + memcpy((void *)fjacb, PyArray_DATA(result_array),`
		`+ (n) (nq) (np) sizeof(double));`
		`+ Py_DECREF(result_array);`
		`+`
		`+ @@ -220,7 +222,7 @@`
		`+ {`
		`+ /* result_array should be rank-3 */`
		`+`
		`+ - if (result_array->nd != 3)`
		`+ + if (PyArray_NDIM(result_array) != 3)`
		`+ {`
		`+ Py_DECREF(result_array);`
		`+ PYERR2(odr_error, "xplusd Jacobian is not rank-3");`
		`+ @@ -230,7 +232,7 @@`
		`+ {`
		`+ /* result_array should be rank-2 */`
		`+`
		`+ - if (result_array->nd != 2)`
		`+ + if (PyArray_NDIM(result_array) != 2)`
		`+ {`
		`+ Py_DECREF(result_array);`
		`+ PYERR2(odr_error, "xplusd Jacobian is not rank-2");`
		`+ @@ -240,14 +242,14 @@`
		`+ {`
		`+ /* result_array should be rank-1 */`
		`+`
		`+ - if (result_array->nd != 1)`
		`+ + if (PyArray_NDIM(result_array) != 1)`
		`+ {`
		`+ Py_DECREF(result_array);`
		`+ PYERR2(odr_error, "xplusd Jacobian is not rank-1");`
		`+ }`
		`+ }`
		`+`
		`+ - memcpy((void *)fjacd, result_array->data,`
		`+ + memcpy((void *)fjacd, PyArray_DATA(result_array),`
		`+ (n) (nq) (m) sizeof(double));`
		`+ Py_DECREF(result_array);`
		`+ }`
		`+ @@ -291,7 +293,7 @@`
		`+ return NULL;`
		`+ }`
		`+`
		`+ - lwkmn = work->dimensions[0];`
		`+ + lwkmn = PyArray_DIMS(work)[0];`
		`+`
		`+ F_FUNC(dwinf,DWINF)(&n, &m, &np, &nq, &ldwe, &ld2we, &isodr,`
		`+ &delta, &eps, &xplus, &fn, &sd, &vcv, &rvar, &wss, &wssde,`
		`+ @@ -352,15 +354,15 @@`
		`+ wrk6--;`
		`+ wrk7--;`
		`+`
		`+ - dim1[0] = beta->dimensions[0];`
		`+ + dim1[0] = PyArray_DIMS(beta)[0];`
		`+ sd_beta = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);`
		`+ - dim2[0] = beta->dimensions[0];`
		`+ - dim2[1] = beta->dimensions[0];`
		`+ + dim2[0] = PyArray_DIMS(beta)[0];`
		`+ + dim2[1] = PyArray_DIMS(beta)[0];`
		`+ cov_beta = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);`
		`+`
		`+ - memcpy(sd_beta->data, (void )((double )(work->data) + sd),`
		`+ + memcpy(PyArray_DATA(sd_beta), (void )((double )(PyArray_DATA(work)) + sd),`
		`+ np * sizeof(double));`
		`+ - memcpy(cov_beta->data, (void )((double )(work->data) + vcv),`
		`+ + memcpy(PyArray_DATA(cov_beta), (void )((double )(PyArray_DATA(work)) + vcv),`
		`+ np * np * sizeof(double));`
		`+`
		`+ if (!full_output)`
		`+ @@ -427,21 +429,21 @@`
		`+ fnA = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);`
		`+ }`
		`+`
		`+ - memcpy(deltaA->data, (void )((double )(work->data) + delta),`
		`+ + memcpy(PyArray_DATA(deltaA), (void )((double )(PyArray_DATA(work)) + delta),`
		`+ m * n * sizeof(double));`
		`+ - memcpy(epsA->data, (void )((double )(work->data) + eps),`
		`+ + memcpy(PyArray_DATA(epsA), (void )((double )(PyArray_DATA(work)) + eps),`
		`+ nq * n * sizeof(double));`
		`+ - memcpy(xplusA->data, (void )((double )(work->data) + xplus),`
		`+ + memcpy(PyArray_DATA(xplusA), (void )((double )(PyArray_DATA(work)) + xplus),`
		`+ m * n * sizeof(double));`
		`+ - memcpy(fnA->data, (void )((double )(work->data) + fn),`
		`+ + memcpy(PyArray_DATA(fnA), (void )((double )(PyArray_DATA(work)) + fn),`
		`+ nq * n * sizeof(double));`
		`+`
		`+ - res_var = ((double )(work->data) + rvar);`
		`+ - sum_square = ((double )(work->data) + wss);`
		`+ - sum_square_delta = ((double )(work->data) + wssde);`
		`+ - sum_square_eps = ((double )(work->data) + wssep);`
		`+ - inv_condnum = ((double )(work->data) + rcond);`
		`+ - rel_error = ((double )(work->data) + eta);`
		`+ + res_var = ((double )(PyArray_DATA(work)) + rvar);`
		`+ + sum_square = ((double )(PyArray_DATA(work)) + wss);`
		`+ + sum_square_delta = ((double )(PyArray_DATA(work)) + wssde);`
		`+ + sum_square_eps = ((double )(PyArray_DATA(work)) + wssep);`
		`+ + inv_condnum = ((double )(PyArray_DATA(work)) + rcond);`
		`+ + rel_error = ((double )(PyArray_DATA(work)) + eta);`
		`+`
		`+ retobj =`
		`+ Py_BuildValue`
		`+ @@ -623,7 +625,7 @@`
		`+ PYERR(PyExc_ValueError,`
		`+ "y could not be made into a suitable array");`
		`+ }`
		`+ - n = y->dimensions[y->nd - 1]; /* pick the last dimension */`
		`+ + n = PyArray_DIMS(y)[PyArray_NDIM(y) - 1]; /* pick the last dimension */`
		`+ if ((x =`
		`+ (PyArrayObject *) PyArray_CopyFromObject(px, NPY_DOUBLE, 1,`
		`+ 2)) == NULL)`
		`+ @@ -631,18 +633,18 @@`
		`+ PYERR(PyExc_ValueError,`
		`+ "x could not be made into a suitable array");`
		`+ }`
		`+ - if (n != x->dimensions[x->nd - 1])`
		`+ + if (n != PyArray_DIMS(x)[PyArray_NDIM(x) - 1])`
		`+ {`
		`+ PYERR(PyExc_ValueError,`
		`+ "x and y don't have matching numbers of observations");`
		`+ }`
		`+ - if (y->nd == 1)`
		`+ + if (PyArray_NDIM(y) == 1)`
		`+ {`
		`+ nq = 1;`
		`+ }`
		`+ else`
		`+ {`
		`+ - nq = y->dimensions[0];`
		`+ + nq = PyArray_DIMS(y)[0];`
		`+ }`
		`+`
		`+ ldx = ldy = n;`
		`+ @@ -664,17 +666,17 @@`
		`+ "x could not be made into a suitable array");`
		`+ }`
		`+`
		`+ - n = x->dimensions[x->nd - 1];`
		`+ + n = PyArray_DIMS(x)[PyArray_NDIM(x) - 1];`
		`+ ldx = n;`
		`+ }`
		`+`
		`+ - if (x->nd == 1)`
		`+ + if (PyArray_NDIM(x) == 1)`
		`+ {`
		`+ m = 1;`
		`+ }`
		`+ else`
		`+ {`
		`+ - m = x->dimensions[0];`
		`+ + m = PyArray_DIMS(x)[0];`
		`+ } /* x, y */`
		`+`
		`+ if ((beta =`
		`+ @@ -684,14 +686,14 @@`
		`+ PYERR(PyExc_ValueError,`
		`+ "initbeta could not be made into a suitable array");`
		`+ }`
		`+ - np = beta->dimensions[0];`
		`+ + np = PyArray_DIMS(beta)[0];`
		`+`
		`+ if (pwe == NULL)`
		`+ {`
		`+ ldwe = ld2we = 1;`
		`+ dim1[0] = n;`
		`+ we = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);`
		`+ - ((double *)(we->data))[0] = -1.0;`
		`+ + ((double *)(PyArray_DATA(we)))[0] = -1.0;`
		`+ }`
		`+ else if (PyNumber_Check(pwe) && !PyArray_Check(pwe))`
		`+ {`
		`+ @@ -711,11 +713,11 @@`
		`+ we = (PyArrayObject *) PyArray_SimpleNew(3, dim3, NPY_DOUBLE);`
		`+ if (implicit)`
		`+ {`
		`+ - ((double *)(we->data))[0] = val;`
		`+ + ((double *)(PyArray_DATA(we)))[0] = val;`
		`+ }`
		`+ else`
		`+ {`
		`+ - ((double *)(we->data))[0] = -val;`
		`+ + ((double *)(PyArray_DATA(we)))[0] = -val;`
		`+ }`
		`+ ldwe = ld2we = 1;`
		`+ }`
		`+ @@ -730,29 +732,29 @@`
		`+ PYERR(PyExc_ValueError, "could not convert we to a suitable array");`
		`+ }`
		`+`
		`+ - if (we->nd == 1 && nq == 1)`
		`+ + if (PyArray_NDIM(we) == 1 && nq == 1)`
		`+ {`
		`+`
		`+ ldwe = n;`
		`+ ld2we = 1;`
		`+ }`
		`+ - else if (we->nd == 1 && we->dimensions[0] == nq)`
		`+ + else if (PyArray_NDIM(we) == 1 && PyArray_DIMS(we)[0] == nq)`
		`+ {`
		`+ /* we is a rank-1 array with diagonal weightings to be broadcast`
		`+ * to all observations */`
		`+ ldwe = 1;`
		`+ ld2we = 1;`
		`+ }`
		`+ - else if (we->nd == 3 && we->dimensions[0] == nq`
		`+ - && we->dimensions[1] == nq && we->dimensions[2] == 1)`
		`+ + else if (PyArray_NDIM(we) == 3 && PyArray_DIMS(we)[0] == nq`
		`+ + && PyArray_DIMS(we)[1] == nq && PyArray_DIMS(we)[2] == 1)`
		`+ {`
		`+ /* we is a rank-3 array with the covariant weightings`
		`+ to be broadcast to all observations */`
		`+ ldwe = 1;`
		`+ ld2we = nq;`
		`+ }`
		`+ - else if (we->nd == 2 && we->dimensions[0] == nq`
		`+ - && we->dimensions[1] == nq)`
		`+ + else if (PyArray_NDIM(we) == 2 && PyArray_DIMS(we)[0] == nq`
		`+ + && PyArray_DIMS(we)[1] == nq)`
		`+ {`
		`+ /* we is a rank-2 array with the full covariant weightings`
		`+ to be broadcast to all observations */`
		`+ @@ -760,16 +762,16 @@`
		`+ ld2we = nq;`
		`+ }`
		`+`
		`+ - else if (we->nd == 2 && we->dimensions[0] == nq`
		`+ - && we->dimensions[1] == n)`
		`+ + else if (PyArray_NDIM(we) == 2 && PyArray_DIMS(we)[0] == nq`
		`+ + && PyArray_DIMS(we)[1] == n)`
		`+ {`
		`+ /* we is a rank-2 array with the diagonal elements of the`
		`+ covariant weightings for each observation */`
		`+ ldwe = n;`
		`+ ld2we = 1;`
		`+ }`
		`+ - else if (we->nd == 3 && we->dimensions[0] == nq`
		`+ - && we->dimensions[1] == nq && we->dimensions[2] == n)`
		`+ + else if (PyArray_NDIM(we) == 3 && PyArray_DIMS(we)[0] == nq`
		`+ + && PyArray_DIMS(we)[1] == nq && PyArray_DIMS(we)[2] == n)`
		`+ {`
		`+ /* we is the full specification of the covariant weights`
		`+ for each observation */`
		`+ @@ -788,7 +790,7 @@`
		`+`
		`+ dim1[0] = m;`
		`+ wd = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);`
		`+ - ((double *)(wd->data))[0] = -1.0;`
		`+ + ((double *)(PyArray_DATA(wd)))[0] = -1.0;`
		`+ }`
		`+ else if (PyNumber_Check(pwd) && !PyArray_Check(pwd))`
		`+ {`
		`+ @@ -806,7 +808,7 @@`
		`+ dim3[1] = 1;`
		`+ dim3[2] = m;`
		`+ wd = (PyArrayObject *) PyArray_SimpleNew(3, dim3, NPY_DOUBLE);`
		`+ - ((double *)(wd->data))[0] = -val;`
		`+ + ((double *)(PyArray_DATA(wd)))[0] = -val;`
		`+ ldwd = ld2wd = 1;`
		`+ }`
		`+ else if (PySequence_Check(pwd))`
		`+ @@ -820,12 +822,12 @@`
		`+ PYERR(PyExc_ValueError, "could not convert wd to a suitable array");`
		`+ }`
		`+`
		`+ - if (wd->nd == 1 && m == 1)`
		`+ + if (PyArray_NDIM(wd) == 1 && m == 1)`
		`+ {`
		`+ ldwd = n;`
		`+ ld2wd = 1;`
		`+ }`
		`+ - else if (wd->nd == 1 && wd->dimensions[0] == m)`
		`+ + else if (PyArray_NDIM(wd) == 1 && PyArray_DIMS(wd)[0] == m)`
		`+ {`
		`+ /* wd is a rank-1 array with diagonal weightings to be broadcast`
		`+ * to all observations */`
		`+ @@ -833,16 +835,16 @@`
		`+ ld2wd = 1;`
		`+ }`
		`+`
		`+ - else if (wd->nd == 3 && wd->dimensions[0] == m`
		`+ - && wd->dimensions[1] == m && wd->dimensions[2] == 1)`
		`+ + else if (PyArray_NDIM(wd) == 3 && PyArray_DIMS(wd)[0] == m`
		`+ + && PyArray_DIMS(wd)[1] == m && PyArray_DIMS(wd)[2] == 1)`
		`+ {`
		`+ /* wd is a rank-3 array with the covariant wdightings`
		`+ to be broadcast to all observations */`
		`+ ldwd = 1;`
		`+ ld2wd = m;`
		`+ }`
		`+ - else if (wd->nd == 2 && wd->dimensions[0] == m`
		`+ - && wd->dimensions[1] == m)`
		`+ + else if (PyArray_NDIM(wd) == 2 && PyArray_DIMS(wd)[0] == m`
		`+ + && PyArray_DIMS(wd)[1] == m)`
		`+ {`
		`+ /* wd is a rank-2 array with the full covariant weightings`
		`+ to be broadcast to all observations */`
		`+ @@ -850,16 +852,16 @@`
		`+ ld2wd = m;`
		`+ }`
		`+`
		`+ - else if (wd->nd == 2 && wd->dimensions[0] == m`
		`+ - && wd->dimensions[1] == n)`
		`+ + else if (PyArray_NDIM(wd) == 2 && PyArray_DIMS(wd)[0] == m`
		`+ + && PyArray_DIMS(wd)[1] == n)`
		`+ {`
		`+ /* wd is a rank-2 array with the diagonal elements of the`
		`+ covariant weightings for each observation */`
		`+ ldwd = n;`
		`+ ld2wd = 1;`
		`+ }`
		`+ - else if (wd->nd == 3 && wd->dimensions[0] == m`
		`+ - && wd->dimensions[1] == m && wd->dimensions[2] == n)`
		`+ + else if (PyArray_NDIM(wd) == 3 && PyArray_DIMS(wd)[0] == m`
		`+ + && PyArray_DIMS(wd)[1] == m && PyArray_DIMS(wd)[2] == n)`
		`+ {`
		`+ /* wd is the full specification of the covariant weights`
		`+ for each observation */`
		`+ @@ -878,7 +880,7 @@`
		`+ {`
		`+ dim1[0] = np;`
		`+ ifixb = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_INT);`
		`+ - (int )(ifixb->data) = -1; /* set first element negative */`
		`+ + (int )(PyArray_DATA(ifixb)) = -1; /* set first element negative */`
		`+ }`
		`+ else`
		`+ {`
		`+ @@ -892,7 +894,7 @@`
		`+ "could not convert ifixb to a suitable array");`
		`+ }`
		`+`
		`+ - if (ifixb->dimensions[0] != np)`
		`+ + if (PyArray_DIMS(ifixb)[0] != np)`
		`+ {`
		`+ PYERR(PyExc_ValueError,`
		`+ "could not convert ifixb to a suitable array");`
		`+ @@ -904,7 +906,7 @@`
		`+ dim2[0] = m;`
		`+ dim2[1] = 1;`
		`+ ifixx = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_INT);`
		`+ - (int )(ifixx->data) = -1; /* set first element negative */`
		`+ + (int )(PyArray_DATA(ifixx)) = -1; /* set first element negative */`
		`+ ldifx = 1;`
		`+ }`
		`+ else`
		`+ @@ -919,16 +921,16 @@`
		`+ "could not convert ifixx to a suitable array");`
		`+ }`
		`+`
		`+ - if (ifixx->nd == 1 && ifixx->dimensions[0] == m)`
		`+ + if (PyArray_NDIM(ifixx) == 1 && PyArray_DIMS(ifixx)[0] == m)`
		`+ {`
		`+ ldifx = 1;`
		`+ }`
		`+ - else if (ifixx->nd == 1 && ifixx->dimensions[0] == n && m == 1)`
		`+ + else if (PyArray_NDIM(ifixx) == 1 && PyArray_DIMS(ifixx)[0] == n && m == 1)`
		`+ {`
		`+ ldifx = n;`
		`+ }`
		`+ - else if (ifixx->nd == 2 && ifixx->dimensions[0] == m`
		`+ - && ifixx->dimensions[1] == n)`
		`+ + else if (PyArray_NDIM(ifixx) == 2 && PyArray_DIMS(ifixx)[0] == m`
		`+ + && PyArray_DIMS(ifixx)[1] == n)`
		`+ {`
		`+ ldifx = n;`
		`+ }`
		`+ @@ -957,14 +959,14 @@`
		`+ {`
		`+ dim1[0] = np;`
		`+ stpb = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);`
		`+ - (double )(stpb->data) = 0.0;`
		`+ + (double )(PyArray_DATA(stpb)) = 0.0;`
		`+ }`
		`+ else /* pstpb is a sequence */`
		`+ {`
		`+ if ((stpb =`
		`+ (PyArrayObject *) PyArray_CopyFromObject(pstpb, NPY_DOUBLE, 1,`
		`+ 1)) == NULL`
		`+ - \|\| stpb->dimensions[0] != np)`
		`+ + \|\| PyArray_DIMS(stpb)[0] != np)`
		`+ {`
		`+ PYERR(PyExc_ValueError,`
		`+ "could not convert stpb to a suitable array");`
		`+ @@ -976,7 +978,7 @@`
		`+ dim2[0] = 1;`
		`+ dim2[1] = m;`
		`+ stpd = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);`
		`+ - (double )(stpd->data) = 0.0;`
		`+ + (double )(PyArray_DATA(stpd)) = 0.0;`
		`+ ldstpd = 1;`
		`+ }`
		`+ else`
		`+ @@ -989,16 +991,16 @@`
		`+ "could not convert stpb to a suitable array");`
		`+ }`
		`+`
		`+ - if (stpd->nd == 1 && stpd->dimensions[0] == m)`
		`+ + if (PyArray_NDIM(stpd) == 1 && PyArray_DIMS(stpd)[0] == m)`
		`+ {`
		`+ ldstpd = 1;`
		`+ }`
		`+ - else if (stpd->nd == 1 && stpd->dimensions[0] == n && m == 1)`
		`+ + else if (PyArray_NDIM(stpd) == 1 && PyArray_DIMS(stpd)[0] == n && m == 1)`
		`+ {`
		`+ ldstpd = n;`
		`+ }`
		`+ - else if (stpd->nd == 2 && stpd->dimensions[0] == n &&`
		`+ - stpd->dimensions[1] == m)`
		`+ + else if (PyArray_NDIM(stpd) == 2 && PyArray_DIMS(stpd)[0] == n &&`
		`+ + PyArray_DIMS(stpd)[1] == m)`
		`+ {`
		`+ ldstpd = n;`
		`+ }`
		`+ @@ -1008,14 +1010,14 @@`
		`+ {`
		`+ dim1[0] = np;`
		`+ sclb = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);`
		`+ - (double )(sclb->data) = 0.0;`
		`+ + (double )(PyArray_DATA(sclb)) = 0.0;`
		`+ }`
		`+ else /* psclb is a sequence */`
		`+ {`
		`+ if ((sclb =`
		`+ (PyArrayObject *) PyArray_CopyFromObject(psclb, NPY_DOUBLE, 1,`
		`+ 1)) == NULL`
		`+ - \|\| sclb->dimensions[0] != np)`
		`+ + \|\| PyArray_DIMS(sclb)[0] != np)`
		`+ {`
		`+ PYERR(PyExc_ValueError,`
		`+ "could not convert sclb to a suitable array");`
		`+ @@ -1027,7 +1029,7 @@`
		`+ dim2[0] = 1;`
		`+ dim2[1] = n;`
		`+ scld = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);`
		`+ - (double )(scld->data) = 0.0;`
		`+ + (double )(PyArray_DATA(scld)) = 0.0;`
		`+ ldscld = 1;`
		`+ }`
		`+ else`
		`+ @@ -1040,16 +1042,16 @@`
		`+ "could not convert stpb to a suitable array");`
		`+ }`
		`+`
		`+ - if (scld->nd == 1 && scld->dimensions[0] == m)`
		`+ + if (PyArray_NDIM(scld) == 1 && PyArray_DIMS(scld)[0] == m)`
		`+ {`
		`+ ldscld = 1;`
		`+ }`
		`+ - else if (scld->nd == 1 && scld->dimensions[0] == n && m == 1)`
		`+ + else if (PyArray_NDIM(scld) == 1 && PyArray_DIMS(scld)[0] == n && m == 1)`
		`+ {`
		`+ ldscld = n;`
		`+ }`
		`+ - else if (scld->nd == 2 && scld->dimensions[0] == n &&`
		`+ - scld->dimensions[1] == m)`
		`+ + else if (PyArray_NDIM(scld) == 2 && PyArray_DIMS(scld)[0] == n &&`
		`+ + PyArray_DIMS(scld)[1] == m)`
		`+ {`
		`+ ldscld = n;`
		`+ }`
		`+ @@ -1110,9 +1112,9 @@`
		`+ PYERR(PyExc_ValueError,`
		`+ "could not convert work to a suitable array");`
		`+ }`
		`+ - if (work->dimensions[0] < lwork)`
		`+ + if (PyArray_DIMS(work)[0] < lwork)`
		`+ {`
		`+ - printf("%d %d\n", work->dimensions[0], lwork);`
		`+ + printf("%ld %d\n", PyArray_DIMS(work)[0], lwork);`
		`+ PYERR(PyExc_ValueError, "work is too small");`
		`+ }`
		`+ }`
		`+ @@ -1133,7 +1135,7 @@`
		`+ "could not convert iwork to a suitable array");`
		`+ }`
		`+`
		`+ - if (iwork->dimensions[0] < liwork)`
		`+ + if (PyArray_DIMS(iwork)[0] < liwork)`
		`+ {`
		`+ PYERR(PyExc_ValueError, "iwork is too small");`
		`+ }`
		`+ @@ -1170,19 +1172,18 @@`
		`+ Py_INCREF(beta);`
		`+ odr_global.extra_args = extra_args;`
		`+ Py_XINCREF(extra_args);`
		`+ -`
		`+ - /* now call DODRC */`
		`+ - F_FUNC(dodrc,DODRC)(fcn_callback, &n, &m, &np, &nq, (double *)(beta->data),`
		`+ - (double )(y->data), &ldy, (double )(x->data), &ldx,`
		`+ - (double *)(we->data), &ldwe, &ld2we,`
		`+ - (double *)(wd->data), &ldwd, &ld2wd,`
		`+ - (int )(ifixb->data), (int )(ifixx->data), &ldifx,`
		`+ - &job, &ndigit, &taufac, &sstol, &partol, &maxit,`
		`+ - &iprint, &lunerr, &lunrpt,`
		`+ - (double )(stpb->data), (double )(stpd->data), &ldstpd,`
		`+ - (double )(sclb->data), (double )(scld->data), &ldscld,`
		`+ - (double )(work->data), &lwork, (int )(iwork->data), &liwork,`
		`+ - &info);`
		`+ + /* now call DODRC */`
		`+ + F_FUNC(dodrc,DODRC)(fcn_callback, &n, &m, &np, &nq, (double *)(PyArray_DATA(beta)),`
		`+ + (double )(PyArray_DATA(y)), &ldy, (double )(PyArray_DATA(x)), &ldx,`
		`+ + (double *)(PyArray_DATA(we)), &ldwe, &ld2we,`
		`+ + (double *)(PyArray_DATA(wd)), &ldwd, &ld2wd,`
		`+ + (int )(PyArray_DATA(ifixb)), (int )(PyArray_DATA(ifixx)), &ldifx,`
		`+ + &job, &ndigit, &taufac, &sstol, &partol, &maxit,`
		`+ + &iprint, &lunerr, &lunrpt,`
		`+ + (double )(PyArray_DATA(stpb)), (double )(PyArray_DATA(stpd)), &ldstpd,`
		`+ + (double )(PyArray_DATA(sclb)), (double )(PyArray_DATA(scld)), &ldscld,`
		`+ + (double )(PyArray_DATA(work)), &lwork, (int )(PyArray_DATA(iwork)), &liwork,`
		`+ + &info);`
		`+`
		`+ result = gen_output(n, m, np, nq, ldwe, ld2we,`
		`+ beta, work, iwork, isodr, info, full_output);`

scipy.spec

file modified

+14 -2

		`@@ -1,5 +1,5 @@`
		`# without means enabled`
		`- %bcond_without doc`
		`+ %bcond_with doc`

		`# Set to pre-release version suffix if building pre-release, else %%{nil}`
		`%global rcver %{nil}`
		`@@ -7,7 +7,7 @@`
		`Summary: Scientific Tools for Python`
		`Name: scipy`
		`Version: 1.2.1`
		`- Release: 3%{?dist}`
		`+ Release: 4%{?dist}`

		`# BSD -- whole package except:`
		`# Boost -- scipy/special/cephes/scipy_iv.c`
		`@@ -21,6 +21,10 @@`
		`# https://stackoverflow.com/a/47731333/1839451`
		`Patch0: acceptable_failure_rate.patch`

		`+ # The C API of PyArrayObject has changed in Python 3.8 and the`
		`+ # structure fields accessed in __odrpack.c are now deprecated.`
		`+ Patch1: numpy-deprecation-warnings.patch`
		`+`
		`BuildRequires: python2-numpy, python2-devel,python2-numpy-f2py`
		`BuildRequires: python2-pytest`
		`BuildRequires: python2-pytest-xdist`
		`@@ -37,6 +41,7 @@`

		`BuildRequires: python3-numpy, python3-devel, python3-numpy-f2py`
		`BuildRequires: python3-setuptools`
		`+ BuildRequires: python3-Cython`
		`BuildRequires: python3-pytest`
		`BuildRequires: python3-pytest-xdist`
		`BuildRequires: python3-pytest-timeout`
		`@@ -135,9 +140,13 @@`
		`%endif`
		`EOF`

		`+ # Docs won't build unless the .dat files are specified here`
		`+ sed -i 's/metadata = dict(/metadata = dict(package_data={"": ["*.dat"]},/' setup.py`
		`+`
		`# remove bundled numpydoc`
		`rm doc/sphinxext -r`

		`+ rm $(grep -rl '/\* Generated by Cython') PKG-INFO`

		`%build`
		`for PY in %{python3_version} %{python2_version}; do`
		`@@ -237,6 +246,9 @@`
		`%endif # with doc`

		`%changelog`
		`+ * Mon Jun 10 2019 Marcel Plch <mplch@redhat.com> - 1.2.1-4`
		`+ - Fix FTBFS with Py3.8 (#1606315)`
		`+`
		`* Thu May 16 2019 Orion Poplawski <orion@nwra.com> - 1.2.1-3`
		`- Build only against openblasp (bugz#1709161)`

dormouse commented 4 years ago

This resolves FTBFS issue in rawhide for scipy on Python 3.8.
Note that the issue still depends on: https://src.fedoraproject.org/rpms/python-pycparser/pull-request/3#

churchyard commented on line 30 of scipy.spec 4 years ago

please add a comment that explains this

churchyard commented 4 years ago

What is the upstream status of the patch?

dormouse commented 4 years ago

Upstream, the patch is not present and only this issue is filed against scipy-1.3:
https://github.com/scipy/scipy/issues/10227

1 new commit added

Add explaining comment

4 years ago

churchyard commented 4 years ago

Is the patch upstreamable? If so, could you please attempt to do that?

lupinix commented on line 32 of scipy.spec 4 years ago

Why do you remove OpenBLAS here? Building without an optimized BLAS leads to extreme performance drop for some operations, also upstream recommends to use and builds its wheels in PyPI with OpenBLAS.

dormouse commented 4 years ago

There are some issues in OpenBLAS and becasue of those, all of the fortran objects return NULL on any call. This is a temporary solution to at least make scipy build.

churchyard commented 4 years ago

FYI the build in Copr is currently running for 18 hours.

https://copr.fedorainfracloud.org/coprs/g/python/python3.8/build/929534/

Not sure if stuck or just slow, however, Copr will AFAIK kill it soon.

1 new commit added