[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index] [Thread Index]

Bug#959134: astroml: (autopkgtest) needs update for new version of numpy: object of type <class 'float'> cannot be safely interpreted as an integer

Source: astroml
Version: 0.4.post1-5
Severity: serious
X-Debbugs-CC: debian-ci@lists.debian.org, numpy@packages.debian.org
Tags: sid bullseye
User: debian-ci@lists.debian.org
Usertags: needs-update
Control: affects -1 src:numpy

Dear maintainer(s),

With a recent upload of numpy the autopkgtest of astroml fails in
testing when that autopkgtest is run with the binary packages of numpy
from unstable. It passes when run with only packages from testing. In
tabular form:

                       pass            fail
numpy                  from testing    1:1.18.3-1
astroml                from testing    0.4.post1-5
all others             from testing    from testing

I copied some of the output at the bottom of this report.

Currently this regression is blocking the migration of numpy to testing
[1]. Of course, numpy shouldn't just break your autopkgtest (or even
worse, your package), but it seems to me that the change in numpy was
intended and your package needs to update to the new situation.

If this is a real problem in your package (and not only in your
autopkgtest), the right binary package(s) from numpy should really add a
versioned Breaks on the unfixed version of (one of your) package(s).
Note: the Breaks is nice even if the issue is only in the autopkgtest as
it helps the migration software to figure out the right versions to
combine in the tests.

More information about this bug and the reason for filing it can be found on


[1] https://qa.debian.org/excuses.php?package=numpy


=================================== FAILURES
_______________________________ test_gaussian1d

start = -6, stop = 10, num = 1000.0, endpoint = True, retstep = False
dtype = None, axis = 0

    def linspace(start, stop, num=50, endpoint=True, retstep=False,
        Return evenly spaced numbers over a specified interval.

        Returns `num` evenly spaced samples, calculated over the
        interval [`start`, `stop`].

        The endpoint of the interval can optionally be excluded.

        .. versionchanged:: 1.16.0
            Non-scalar `start` and `stop` are now supported.

        start : array_like
            The starting value of the sequence.
        stop : array_like
            The end value of the sequence, unless `endpoint` is set to
            In that case, the sequence consists of all but the last of
``num + 1``
            evenly spaced samples, so that `stop` is excluded.  Note
that the step
            size changes when `endpoint` is False.
        num : int, optional
            Number of samples to generate. Default is 50. Must be
        endpoint : bool, optional
            If True, `stop` is the last sample. Otherwise, it is not
            Default is True.
        retstep : bool, optional
            If True, return (`samples`, `step`), where `step` is the spacing
            between samples.
        dtype : dtype, optional
            The type of the output array.  If `dtype` is not given,
infer the data
            type from the other input arguments.

            .. versionadded:: 1.9.0

        axis : int, optional
            The axis in the result to store the samples.  Relevant only
if start
            or stop are array-like.  By default (0), the samples will be
along a
            new axis inserted at the beginning. Use -1 to get an axis at
the end.

            .. versionadded:: 1.16.0

        samples : ndarray
            There are `num` equally spaced samples in the closed interval
            ``[start, stop]`` or the half-open interval ``[start, stop)``
            (depending on whether `endpoint` is True or False).
        step : float, optional
            Only returned if `retstep` is True

            Size of spacing between samples.

        See Also
        arange : Similar to `linspace`, but uses a step size (instead of the
                 number of samples).
        geomspace : Similar to `linspace`, but with numbers spaced
evenly on a log
                    scale (a geometric progression).
        logspace : Similar to `geomspace`, but with the end points
specified as

        >>> np.linspace(2.0, 3.0, num=5)
        array([2.  , 2.25, 2.5 , 2.75, 3.  ])
        >>> np.linspace(2.0, 3.0, num=5, endpoint=False)
        array([2. ,  2.2,  2.4,  2.6,  2.8])
        >>> np.linspace(2.0, 3.0, num=5, retstep=True)
        (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)

        Graphical illustration:

        >>> import matplotlib.pyplot as plt
        >>> N = 8
        >>> y = np.zeros(N)
        >>> x1 = np.linspace(0, 10, N, endpoint=True)
        >>> x2 = np.linspace(0, 10, N, endpoint=False)
        >>> plt.plot(x1, y, 'o')
        [<matplotlib.lines.Line2D object at 0x...>]
        >>> plt.plot(x2, y + 0.5, 'o')
        [<matplotlib.lines.Line2D object at 0x...>]
        >>> plt.ylim([-0.5, 1])
        (-0.5, 1)
        >>> plt.show()

>           num = operator.index(num)
E           TypeError: 'float' object cannot be interpreted as an integer

/usr/lib/python3/dist-packages/numpy/core/function_base.py:117: TypeError

Attachment: signature.asc
Description: OpenPGP digital signature

Reply to: