#9 Fix FTBFS with Py3.8
Merged 2 months ago by churchyard. Opened 3 months ago by dormouse.
rpms/ dormouse/scipy master  into  master

@@ -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);

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)

  

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#

please add a comment that explains this

What is the upstream status of the patch?

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
3 months ago

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

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.

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.

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

  • Reenable OpenBLAS
2 months ago

rebased onto 180d901

2 months ago

trying a docs enabled build on 3.7 https://koji.fedoraproject.org/koji/taskinfo?taskID=36033476

if it works, we should enable the docs and only disable it for 3.8 (we can do it with conditional even).

Docs could be fixed by updating to 1.3.0.

We can update and fix that later.

As observed by @dormouse, the 3.8 copr builds hang. However the 3.8 mock builds should not. I'm testing this locally.

My mock build against 3.8.0b2 is finishing. Seems like this indeed fixes the build failure \o/.

Pull-Request has been merged by churchyard

2 months ago