python-audiolazy-0.6-bp151.1.3

- Remove superfluous devel dependency for noarch package

- Start the description with a main clause, not
  some lengthy subclause.

- Implement single-spec version
- Update to Version 0.6
  + examples:
  * Formant synthesis for voiced "ah-eh-ee-oh-oo"
  * Musical keyboard synth example with a QWERTY keyboard (also via jack!)
  * Random synthesis with saving and memoization
  * Aesthetics for the Tkinter GUI examples
  * Matplotlib animated plot with mic input data (also works via jack!)
  * Perceptual experiment with butterworth filters (Scipy) applied to white
    noise (based on the Demonstrations to Auditory Scene Analysis)
  * Psychoacoustics using ISO/FDIS 226:2003
    > Equal loudness contour curves plotting
    > Constant phon chirp playing
  * Partial recreation of the "Windows and Figures of Merit" F. Harris
    comparison table and window plots
  * Playing/synthesizing "Ode to Joy" from its "score" written as code
  * All recording/playback examples now prepared for using both the default
    API and receiving it as an argument like "jack" or "alsa"
  * Realtime STFT (Short Time Fourier Transform) effects:
    > Robotize
    > "Roll" the magnitude spectrum while keeping the phase
  + general:
  * Tox for testing with CPython 2.7, CPython 3.2~3.6 and PyPy
  * Continuous integration wih Travis CI and Coveralls
  * New ``_internals.py`` module to avoid exposing package internals together
    with the API, which also allowed the new simplified ``__init__.py``
  * Renewed setup.py in both its internals (e.g. using AST instead of
    string manipulation to avoid importing the package before installation)
    and its interface (e.g. the ``test`` command now calls ``tox``)
  * New ``conftest.py`` for testing doctests from strategies inside
    StrategyDict instances without the need of a ``__test__`` in the module
    and for skipping doctests known to need Numpy when it's not available
  * New ``math`` directory for adding scripts with symbolic math calculations
    (with Sympy) done for designing (or as a proof) for parts of the
    AudioLazy code. All lowpass and highpass strategies have their design
    explicitly explained there
  + lazy_analysis:
  * New ``overlap_add`` StrategyDict instance, allowing resynth after block
    processing/analysis, featuring block size auto-detection and window
    normalization to keep the output in the [-1; 1] range. Has 2
    implementations keeping the same interface:
    > ``numpy`` (*default*): needs Numpy arrays internally
    > ``list``: uses lists instead, doesn't need Numpy and was tested on Pypy
  * New ``stft`` StrategyDict instance, allowing Short Time Fourier Transform
    block processors / phase vocoder by:
    > Passing a function as the first parameter
    > Using a ``stft`` strategies as a decorator
    > Creating new strategies by avoiding the only positional parameter
    It was created with three Numpy-based strategies:
    > ``rfft``, ``real`` or ``base`` (*default*): needs ``numpy.fft.rfft``
    internally, as well as its inverse, to process a block in the
    frequency domain with values up to the Nyquist frequency, by assuming
    the input signal is real
    > ``cfft`` or ``complex``: Alike to the default approach but uses the
    ``numpy.fft.fft`` for a full complex-valued block in frequency domain,
    which means the output is a complex signal
    > ``cfftr`` or ``complex_real``: same to ``stft.cfft`` strategy, but
    keeps only the real part of the result
    Parameters allows changing the default zero-phase behavior (``before``
    and ``after`` functions), the transform and inverse transform functions,
    the overlap-add strategy (as well as its parameters), and obviously the
    block size and hop
  * The ``window`` StrategyDict now returns the "periodic" window data
    instead of the "symmetric" window to be used with the STFT directly
  * New ``wsymm`` StrategyDict with the same strategies from ``window`` but
    returning a "symmetric" window
  * Default ``window`` strategy is the Hann window (the same for ``wsymm``)
  * New ``cos`` strategy for ``window`` and ``wsymm`` implementing cosine to
    the power of alpha
  + lazy_auditory:
  * New ``phon2dB`` StrategyDict instance with the ISO/FDIS 226:2003 model
    for getting a SPL (Sound Pressure Level) in dBs from a phon value
  + lazy_core:
  * Add support to the new ``@`` matrix multiplication operator
  * ``OpMethod.get()`` now accepts numbers ``"1"`` and ``"2"`` as strings for
    unary and binary query for operators, and ``"all"`` is the new default, so
    ``OpMethod.get(without="2 ~")`` would get all operators but the [reversed
    or not] binary ones and the invert operator, which means it would yield
    only the unary ``"+"`` (pos) and ``-`` (neg), as probably was expected;
    OpMethod also had a bug fix regarding the shift operators
  * Strategy name autocomplete works on IPython since StrategyDict now
    changes its instance dictionary (e.g. ``vars(window)``) instead of
    depending on the ``__getattr__`` method
  * ``StrategyDict.strategy`` method now allows the strategy function name to
    be kept by using the new ``keep_name`` keyword-only argument. It might be
    helpful for adding built-in functions as well as other immutable
    callables as multi-name strategies with the same behavior as the item
    assignment for adding a strategy
  * The default strategy in a StrategyDict instance is now removed when all
    its keys/names are removed. The new default is the next added strategy
  * Strategies can be removed both by their item name and their attribute,
    and removing an attribute that isn't an strategy recovers the strategy
    attribute if its name belongs to a strategy
  * MultiKeyDict methods ``key2keys`` and ``value2keys`` to help getting a
    tuple with all keys that points to the same value, ordered by the
    insertion order
  + lazy_filters:
  * LinearFilter coefficients can now be a Stream of Numpy matrices, as well
    as Sympy symbols (including symbolic matrices).
  * New simple lowpass/highpass IIR filter strategies:
    > ``highpass.z`` (taken as the new ``highpass`` default)
    > ``lowpass.z``
    > ``highpass.pole_exp``
    > ``highpass.z_exp``
    > ``lowpass.z_exp``
    Where the ``"z"`` name denotes the presence of a single zero (besides the
    single pole) and ``"_exp"`` denotes the exponential approximation from
    a matched Z-Transform pole value from the equivalent or mirrored analog
    filter equation (Laplace). The absence of such suffix denotes it was
    designed directly as a digital filter.
  + lazy_io:
  * New ``api`` keyword argument for AudioIO, allowing e.g. integration with
    JACK (for now this needs ``chunks.size = 1``)
  * ``AudioIO.open`` and ``AudioIO.record`` now allows keyword arguments, to
    be passed directly to PyAudio, including the now default "channels"
    keyword (old "nchannels" keyword still works, for backward compatibility)
  + lazy_math:
  * Signal function ``sign`` now works on Python 3
  + lazy_misc:
  * New ``cached`` decorator caching the results for a function without
    keyword arguments
  + lazy_poly:
  * Complex numbers and Sympy symbols can now be used as Poly powers
  * Poly instances are now based on OrderedDict (stores the creation order
    internally) and Poly.terms now support both a ``sort`` and a ``reverse``
    keyword arguments to choose the yielding order (sorted by powers, keep
    creation order or reverse any of these)
  * Immutable Poly behavior is now based on a cached frozenset (doesn't depend
    on the terms order) and includes Poly.zero as a read-only property (after
    the hash is required)
  * The Horner-like polynomial evaluation scheme (which needs sorting) is now
    enabled/disabled via a keyword argument. By default, it's enabled just for
    simple polynomials, but optional when powers are sortable (e.g. in a
    Laurent polynomial)
  + lazy_text:
  * New ``format_docstring`` decorator that use format-style templates to
    assign docstrings to functions, intended to avoid docstring copies on
    StrategyDict instances.
  + lazy_wav (*new!*):
  * ``WavStream`` class for opening Wave files. Can load 24-bit audio files!
    Tested with 8 bits files (unsigned int) and 16/24/32 bits (signed int)
    mono and stereo files, both casting the data to a float in [-1;1) interval
    (default) and keeping the original integer data as it is
  + multiple modules:
  * (*lazy_math and lazy_stream*) Renamed the elementwised ``abs`` to
    ``absolute``, so no Python built-in name is ever replaced when importing
    with ``from audiolazy import *``. Also, the built-in ``abs`` now can be
    used directly with Stream instances
  * (*lazy_analysis and lazy_misc*) Renamed ``freq2lag`` and ``lag2freq`` to
    use ``2`` instead of ``_to_``, and moved them to lazy_misc

- Fix files list

- - Initial version