diff --git a/numpy-deprecation-warnings.patch b/numpy-deprecation-warnings.patch new file mode 100644 index 0000000..5099879 --- /dev/null +++ b/numpy-deprecation-warnings.patch @@ -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); diff --git a/scipy.spec b/scipy.spec index 2b87af2..e5dc383 100644 --- a/scipy.spec +++ b/scipy.spec @@ -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 @@ Source0: https://github.com/scipy/scipy/releases/download/v%{version}/scipy-% # 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: /usr/bin/pathfix.py 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 @@ library_dirs = %{_libdir} %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 @@ popd %endif # with doc %changelog +* Mon Jun 10 2019 Marcel Plch - 1.2.1-4 +- Fix FTBFS with Py3.8 (#1606315) + * Thu May 16 2019 Orion Poplawski - 1.2.1-3 - Build only against openblasp (bugz#1709161)