Bug#918052: python-ltfatpy FTBFS: TestPsech.test_exceptions failure

[Adrian Bunk]

Source: python-ltfatpy
Version: 1.0.12-1
Severity: serious
Tags: ftbfs

https://buildd.debian.org/status/package.php?p=python-ltfatpy&suite=sid

...
=================================== FAILURES ===================================
__________________________ TestPsech.test_exceptions ___________________________

self = <ltfatpy.tests.fourier.test_psech.TestPsech testMethod=test_exceptions>

    def test_exceptions(self):
        mess = "\nException TypeError should be raised with declaration "
        mess += "psech(10.2)\n"
        self.assertRaises(TypeError, psech, 10.2, mess)
        mess = "\nException TypeError should be raised with declaration "
        mess += "psech(10,(1,1))\n"
>       self.assertRaises(TypeError, psech, 10, (1, 1))

ltfatpy/tests/fourier/test_psech.py:93: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

    def psech(L, tfr=None, s=None, **kwargs):
        """Sampled, periodized hyperbolic secant
    
        - Usage:
    
            | ``(g, tfr) = psech(L)``
            | ``(g, tfr) = psech(L, tfr)``
            | ``(g, tfr) = psech(L, s=...)``
    
        - Input parameters:
    
        :param int L: length of vector.
        :param float tfr: ratio between time and frequency support.
        :param int s: number of samples (equivalent to :math:`tfr=s^2/L`)
    
        - Output parameters:
    
        :returns: ``(g, tfr)``
        :rtype: tuple
        :var numpy.ndarray g: periodized hyperbolic cosine
        :var float tfr: calculated ratio between time and frequency support
    
        ``psech(L,tfr)`` computes samples of a periodized hyperbolic secant.
        The function returns a regular sampling of the periodization
        of the function :math:`sech(\pi\cdot x)`
    
        The returned function has norm equal to 1.
    
        The parameter **tfr** determines the ratio between the effective support
        of **g** and the effective support of the DFT of **g**. If **tfr** > 1
        then **g** has a wider support than the DFT of **g**.
    
        ``psech(L)`` does the same setting than **tfr** = 1.
    
        ``psech(L,s)`` returns a hyperbolic secant with an effective support of
        **s** samples. This means that approx. 96% of the energy or 74% or the
        area under the graph is contained within **s** samples. This is
        equivalent to ``psech(L,s^2/L)``.
    
        ``(g,tfr) = psech( ... )`` returns the time-to-frequency support ratio.
        This is useful if you did not specify it (i.e. used the **s** input
        format).
    
        The function is whole-point even.  This implies that
        ``fft(psech(L,tfr))`` is real for any **L** and **tfr**.
    
        If this function is used to generate a window for a Gabor frame, then
        the window giving the smallest frame bound ratio is generated by
        ``psech(L,a*M/L)``.
    
        - Examples:
    
            This example creates a ``psech`` function, and demonstrates that it
            is its own Discrete Fourier Transform:
    
            >>> import numpy as np
            >>> import numpy.linalg as nla
            >>> g = psech(128)[0] # DFT invariance: Should be close to zero.
            >>> diff = nla.norm(g-np.fft.fft(g)/np.sqrt(128))
            >>> np.abs(diff) < 10e-10
            True
    
        .. seealso:: :func:`~ltfatpy.fourier.pgauss.pgauss`, :func:`pbspline`,
            :func:`pherm`
    
        - References:
            :cite:`jast02-1`
        """
        if not isinstance(L, six.integer_types):
            raise TypeError('L must be an integer')
    
        if s is not None:
            if not isinstance(s, six.integer_types):
                raise TypeError('s must be an integer')
            tfr = float(s**2 / L)
        elif tfr is None:
            tfr = 1
    
        safe = 12
        g = np.zeros(L)
        sqrtl = np.sqrt(L)
        w = tfr
    
        # Outside the interval [-safe,safe] then sech(pi*x) is numerically zero.
        nk = np.ceil(safe / np.sqrt(L / np.sqrt(w)))
    
        lr = np.arange(L)
>       for k in np.arange(-nk, nk+1):
E       ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

ltfatpy/fourier/psech.py:157: ValueError
...
============= 1 failed, 138 passed, 291 warnings in 59.44 seconds ==============
E: pybuild pybuild:338: test: plugin distutils failed with: exit code=1: cd /<<PKGBUILDDIR>>/.pybuild/cpython3_3.7_ltfatpy/build; python3.7 -m pytest 
dh_auto_test: pybuild --test --test-pytest -i python{version} -p 3.7 returned exit code 13
make[1]: *** [debian/rules:15: override_dh_auto_test] Error 25