
    }Kg&l                     F	   d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlm	Z	 ddl
mZ dd	lmZmZmZmZmZmZmZmZ dd
lmZ ddlmZ ddlmZmZmZmZmZmZm Z m!Z! g dZ"ddddddddddd
dejF                  dee ee e f   ee    f   de$de%dee!ee!e!f   ee!   f   de&dee&   dee&   ded e%d!ed"eejF                  ejF                  f   fd#Z'ddddddddddd
dejF                  dee ee e f   ee    f   de$de%dee!ee!e!f   ee!   f   de&dee&   dee&   ded e%d!ed"ejF                  fd$Z(ddddddddddd
dejF                  dee ee e f   ee    f   de$de%dee!ee!e!f   ee!   f   de&dee&   dee&   ded e%d!ed"ejF                  fd%Z)dejF                  d&e$d'ed"ejF                  fd(Z*d)d*dd+dejF                  d,e$d-e$d.e&d/e+d0e%d'ed"ejF                  fd1Z,dd2dejF                  d3eee&e&f      d4e%d"ejF                  fd5Z-dd6d7ej\                  ej\                  fdejF                  d8e&de&d9e$d:eee$f   d;ed"ejF                  fd<Z/d7ej\                  dd6ej\                  d=dejF                  d9e$d:ee$ef   d8e&de&d;ed"eejF                  ejF                  f   fd>Z0d7ej\                  dd6ej\                  d=dejF                  d9e$d:ee$ef   d8e&de&d;ed"ejF                  fd?Z1ed@d@d@dAdejF                  dBe$dCee   dDed   d"ejF                  f
dE       Z2ed@d@dFdejF                  dBe$dCee   dDed   d"eejF                  ejF                  f   f
dG       Z2ed@d@dFdejF                  dBe$dCee   dDe%d"eejF                  eejF                  ejF                  f   f   f
dH       Z2dIdddAdejF                  dBe$dCee   dDe%d"eejF                  eejF                  ejF                  f   f   f
dJZ2ed@d@d@dAdejF                  dBe$dCee   dDed   d"ejF                  f
dK       Z3ed@d@dFdejF                  dBe$dCee   dDed   d"eejF                  ejF                  f   f
dL       Z3dIdddAdejF                  dBe$dCee   dDe%d"eejF                  eejF                  ejF                  f   f   f
dMZ3y)Na  
Effects
=======

Harmonic-percussive source separation
-------------------------------------
.. autosummary::
    :toctree: generated/

    hpss
    harmonic
    percussive

Time and frequency
------------------
.. autosummary::
    :toctree: generated/

    time_stretch
    pitch_shift

Miscellaneous
-------------
.. autosummary::
    :toctree: generated/

    remix
    trim
    split
    preemphasis
    deemphasis
    N   )core)	decompose)feature)util)ParameterError)AnyCallableIterableOptionalTupleListUnionoverload)Literal)	ArrayLike)_WindowSpec_PadMode_PadModeSTFT_SequenceLike_ScalarOrSequence_ComplexLike_co_IntLike_co_FloatLike_co)hpssharmonic
percussivetime_stretchpitch_shiftremixtrimsplit          @F      ?i   hannTconstant)
kernel_sizepowermaskmarginn_fft
hop_length
win_lengthwindowcenterpad_modeyr(   r)   r*   r+   r,   r-   r.   r/   r0   r1   returnc       
   
      F   t        j                  | ||||	|
      }t        j                  |||||      \  }}t        j                  || j
                  ||||	| j                  d         }t        j                  || j
                  ||||	| j                  d         }||fS )a  Decompose an audio time series into harmonic and percussive components.

    This function automates the STFT->HPSS->ISTFT pipeline, and ensures that
    the output waveforms have equal length to the input waveform ``y``.

    Parameters
    ----------
    y : np.ndarray [shape=(..., n)]
        audio time series. Multi-channel is supported.
    kernel_size
    power
    mask
    margin
        See `librosa.deocmpose.hpss`
    n_fft
    hop_length
    win_length
    window
    center
    pad_mode
        See `librosa.stft`

    Returns
    -------
    y_harmonic : np.ndarray [shape=(..., n)]
        audio time series of the harmonic elements
    y_percussive : np.ndarray [shape=(..., n)]
        audio time series of the percussive elements

    See Also
    --------
    harmonic : Extract only the harmonic component
    percussive : Extract only the percussive component
    librosa.decompose.hpss : HPSS on spectrograms

    Examples
    --------
    >>> # Extract harmonic and percussive components
    >>> y, sr = librosa.load(librosa.ex('choice'))
    >>> y_harmonic, y_percussive = librosa.effects.hpss(y)

    >>> # Get a more isolated percussive component by widening its margin
    >>> y_harmonic, y_percussive = librosa.effects.hpss(y, margin=(1.0,5.0))
    r,   r-   r.   r0   r1   r(   r)   r*   r+   dtyper,   r-   r.   r0   lengthr   stftr   r   istftr9   shape)r2   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r<   	stft_harm	stft_percy_harmy_percs                   S/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/librosa/effects.pyr   r   F   s    ~ 99	D %>>+UfIy
 ZZggwwr{F ZZggwwr{F 6>    c       
   
          t        j                  | ||||	|
      }t        j                  |||||      d   }t        j                  || j
                  ||||	| j                  d         }|S )a  Extract harmonic elements from an audio time-series.

    Parameters
    ----------
    y : np.ndarray [shape=(..., n)]
        audio time series. Multi-channel is supported.
    kernel_size
    power
    mask
    margin
        See `librosa.deocmpose.hpss`
    n_fft
    hop_length
    win_length
    window
    center
    pad_mode
        See `librosa.stft`

    Returns
    -------
    y_harmonic : np.ndarray [shape=(..., n)]
        audio time series of just the harmonic portion

    See Also
    --------
    hpss : Separate harmonic and percussive components
    percussive : Extract only the percussive component
    librosa.decompose.hpss : HPSS for spectrograms

    Examples
    --------
    >>> # Extract harmonic component
    >>> y, sr = librosa.load(librosa.ex('choice'))
    >>> y_harmonic = librosa.effects.harmonic(y)

    >>> # Use a margin > 1.0 for greater harmonic separation
    >>> y_harmonic = librosa.effects.harmonic(y, margin=3.0)
    r5   r6   r   r7   r8   r;   )r2   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r<   r?   rA   s                 rC   r   r          t 99	D +Uf	I
 ZZggwwr{F MrD   c       
   
          t        j                  | ||||	|
      }t        j                  |||||      d   }t        j                  || j
                  ||||	| j                  d         }|S )a  Extract percussive elements from an audio time-series.

    Parameters
    ----------
    y : np.ndarray [shape=(..., n)]
        audio time series. Multi-channel is supported.
    kernel_size
    power
    mask
    margin
        See `librosa.deocmpose.hpss`
    n_fft
    hop_length
    win_length
    window
    center
    pad_mode
        See `librosa.stft`

    Returns
    -------
    y_percussive : np.ndarray [shape=(..., n)]
        audio time series of just the percussive portion

    See Also
    --------
    hpss : Separate harmonic and percussive components
    harmonic : Extract only the harmonic component
    librosa.decompose.hpss : HPSS for spectrograms

    Examples
    --------
    >>> # Extract percussive component
    >>> y, sr = librosa.load(librosa.ex('choice'))
    >>> y_percussive = librosa.effects.percussive(y)

    >>> # Use a margin > 1.0 for greater percussive separation
    >>> y_percussive = librosa.effects.percussive(y, margin=3.0)
    r5   r6   r   r7   r8   r;   )r2   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r<   r@   rB   s                 rC   r   r      rF   rD   ratekwargsc          	      R   |dk  rt        d      t        j                  | fi |}t        j                  |||j	                  dd      |j	                  dd            }t        t        | j                  d   |z              }t        j                  |f| j                  |d|}|S )	a  Time-stretch an audio series by a fixed rate.

    Parameters
    ----------
    y : np.ndarray [shape=(..., n)]
        audio time series. Multi-channel is supported.
    rate : float > 0 [scalar]
        Stretch factor.  If ``rate > 1``, then the signal is sped up.
        If ``rate < 1``, then the signal is slowed down.
    **kwargs : additional keyword arguments.
        See `librosa.decompose.stft` for details.

    Returns
    -------
    y_stretch : np.ndarray [shape=(..., round(n/rate))]
        audio time series stretched by the specified rate

    See Also
    --------
    pitch_shift :
        pitch shifting
    librosa.phase_vocoder :
        spectrogram phase vocoder
    pyrubberband.pyrb.time_stretch :
        high-quality time stretching using RubberBand

    Examples
    --------
    Compress to be twice as fast

    >>> y, sr = librosa.load(librosa.ex('choice'))
    >>> y_fast = librosa.effects.time_stretch(y, rate=2.0)

    Or half the original speed

    >>> y_slow = librosa.effects.time_stretch(y, rate=0.5)
    r   zrate must be a positive numberr-   Nr,   )rH   r-   r,   r7   )r9   r:   )
r   r   r<   phase_vocodergetintroundr>   r=   r9   )r2   rH   rI   r<   stft_stretchlen_stretch	y_stretchs          rC   r   r   V  s    L qy=>> 99Q!&!D %%::lD1jj$'	L eAGGBK$./0K 

<Uqww{UfUIrD      soxr_hq)bins_per_octaveres_typescalesrn_stepsrT   rU   rV   c                   t        j                  |      st        d| d      dt        |       |z  z  }t	        j
                  t        | fd|i|t        |      |z  |||      }t        j                  || j                  d         S )a  Shift the pitch of a waveform by ``n_steps`` steps.

    A step is equal to a semitone if ``bins_per_octave`` is set to 12.

    Parameters
    ----------
    y : np.ndarray [shape=(..., n)]
        audio time series. Multi-channel is supported.

    sr : number > 0 [scalar]
        audio sampling rate of ``y``

    n_steps : float [scalar]
        how many (fractional) steps to shift ``y``

    bins_per_octave : int > 0 [scalar]
        how many steps per octave

    res_type : string
        Resample type. By default, 'soxr_hq' is used.

        See `librosa.resample` for more information.

    scale : bool
        Scale the resampled signal so that ``y`` and ``y_hat`` have approximately
        equal total energy.

    **kwargs : additional keyword arguments.
        See `librosa.decompose.stft` for details.

    Returns
    -------
    y_shift : np.ndarray [shape=(..., n)]
        The pitch-shifted audio time-series

    See Also
    --------
    time_stretch :
        time stretching
    librosa.phase_vocoder :
        spectrogram phase vocoder
    pyrubberband.pyrb.pitch_shift :
        high-quality pitch shifting using RubberBand

    Examples
    --------
    Shift up by a major third (four steps if ``bins_per_octave`` is 12)

    >>> y, sr = librosa.load(librosa.ex('choice'))
    >>> y_third = librosa.effects.pitch_shift(y, sr=sr, n_steps=4)

    Shift down by a tritone (six steps if ``bins_per_octave`` is 12)

    >>> y_tritone = librosa.effects.pitch_shift(y, sr=sr, n_steps=-6)

    Shift up by 3 quarter-tones

    >>> y_three_qt = librosa.effects.pitch_shift(y, sr=sr, n_steps=3,
    ...                                          bins_per_octave=24)
    zbins_per_octave=z must be a positive integer.r$   rH   )orig_sr	target_srrU   rV   r7   )size)	r   is_positive_intr   floatr   resampler   
fix_lengthr>   )	r2   rW   rX   rT   rU   rV   rI   rH   y_shifts	            rC   r   r     s    L 0//KL
 	
 E'N?_45D mmQ,T,V,b	D G ??755rD   )align_zeros	intervalsrb   c                x   g }|r`t        j                  |       }t        j                  t        j                  |            d   }t        j
                  |t        |      g      }|D ];  }|rt        j                  ||         }|j                  | d|d   |d   f          = t        j                  |d      S )a^  Remix an audio signal by re-ordering time intervals.

    Parameters
    ----------
    y : np.ndarray [shape=(..., t)]
        Audio time series. Multi-channel is supported.
    intervals : iterable of tuples (start, end)
        An iterable (list-like or generator) where the ``i``th item
        ``intervals[i]`` indicates the start and end (in samples)
        of a slice of ``y``.
    align_zeros : boolean
        If ``True``, interval boundaries are mapped to the closest
        zero-crossing in ``y``.  If ``y`` is stereo, zero-crossings
        are computed after converting to mono.

    Returns
    -------
    y_remix : np.ndarray [shape=(..., d)]
        ``y`` remixed in the order specified by ``intervals``

    Examples
    --------
    Load in the example track and reverse the beats

    >>> y, sr = librosa.load(librosa.ex('choice'))

    Compute beats

    >>> _, beat_frames = librosa.beat.beat_track(y=y, sr=sr,
    ...                                          hop_length=512)

    Convert from frames to sample indices

    >>> beat_samples = librosa.frames_to_samples(beat_frames)

    Generate intervals from consecutive events

    >>> intervals = librosa.util.frame(beat_samples, frame_length=2,
    ...                                hop_length=1).T

    Reverse the beat intervals

    >>> y_out = librosa.effects.remix(y, intervals[::-1])
    r7   .r   r   axis)
r   to_mononpnonzerozero_crossingsappendlenr   match_eventsconcatenate)r2   rc   rb   y_outy_monozerosintervals          rC   r    r      s    ^ Ea

4..v67;		%#f+/T..x?@HQsHQK(1+5567	  >>%b))rD   i   <   frame_lengthtop_dbref	aggregatec           	      b   t        j                  | ||      }t        j                  |ddddf   |d      }|j                  dkD  rct        j                  ||t        |j                  dz
              }t        j                  |t        t        |j                  dz
                    }|| kD  S )a?  Frame-wise non-silent indicator for audio input.

    This is a helper function for `trim` and `split`.

    Parameters
    ----------
    y : np.ndarray
        Audio signal, mono or stereo

    frame_length : int > 0
        The number of samples per frame

    hop_length : int > 0
        The number of samples between frames

    top_db : number > 0
        The threshold (in decibels) below reference to consider as
        silence

    ref : callable or float
        The reference amplitude

    aggregate : callable [default: np.max]
        Function to aggregate dB measurements across channels (if y.ndim > 1)

        Note: for multiple leading axes, this is performed using ``np.apply_over_axes``.

    Returns
    -------
    non_silent : np.ndarray, shape=(m,), dtype=bool
        Indicator of non-silent frames
    )r2   rt   r-   .r   N)rv   ru   r   re   )
r   rmsr   amplitude_to_dbndimrh   apply_over_axesrangesqueezetuple)r2   rt   r-   ru   rv   rw   msedbs           rC   _signal_to_frame_nonsilentr   -  s    R ++
LC ))#c1ai.c$OB 
ww{	2uRWWq[/AB ZZuRWWq['9!:;<rD   )ru   rv   rt   r-   rw   c          	         t        | |||||      }t        j                  |      }|j                  dkD  rat	        t        j                  |d   |            }t        | j                  d   t	        t        j                  |d   dz   |                  }	nd\  }}	t        d      g| j                  z  }
t        ||	      |
d<   | t        |
         t        j                  ||	g      fS )a  Trim leading and trailing silence from an audio signal.

    Silence is defined as segments of the audio signal that are `top_db`
    decibels (or more) quieter than a reference level, `ref`.
    By default, `ref` is set to the signal's maximum RMS value.
    It's important to note that if the entire signal maintains a uniform
    RMS value, there will be no segments considered quieter than the maximum,
    leading to no trimming.
    This implies that a completely silent signal will remain untrimmed with the default `ref` setting.
    In these situations, an explicit value for `ref` (in decibels) should be used instead.

    Parameters
    ----------
    y : np.ndarray, shape=(..., n)
        Audio signal. Multi-channel is supported.
    top_db : number > 0
        The threshold (in decibels) below reference to consider as
        silence
    ref : number or callable
        The reference amplitude.  By default, it uses `np.max` and compares
        to the peak amplitude in the signal.
    frame_length : int > 0
        The number of samples per analysis frame
    hop_length : int > 0
        The number of samples between analysis frames
    aggregate : callable [default: np.max]
        Function to aggregate across channels (if y.ndim > 1)

    Returns
    -------
    y_trimmed : np.ndarray, shape=(..., m)
        The trimmed signal
    index : np.ndarray, shape=(2,)
        the interval of ``y`` corresponding to the non-silent region:
        ``y_trimmed = y[index[0]:index[1]]`` (for mono) or
        ``y_trimmed = y[:, index[0]:index[1]]`` (for stereo).

    Examples
    --------
    >>> # Load some audio
    >>> y, sr = librosa.load(librosa.ex('choice'))
    >>> # Trim the beginning and ending silence
    >>> yt, index = librosa.effects.trim(y)
    >>> # Print the durations
    >>> print(librosa.get_duration(y, sr=sr), librosa.get_duration(yt, sr=sr))
    25.025986394557822 25.007891156462584
    rt   r-   rv   ru   rw   r   r-   r7   r   )r   r   N)r   rh   flatnonzeror\   rM   r   frames_to_samplesminr>   slicer{   r   asarray)r2   ru   rv   rt   r-   rw   
non_silentri   startend
full_indexs              rC   r!   r!   e  s    p ,	!J nnZ(G||a D**71:*MNGGBK&&wr{Q:NO
 
s +'J5#&JrNU:UCL!999rD   c                "   t        | |||||      }t        j                  t        j                  |j	                  t
                          }|dz   g}|d   r&|j                  dt        j                  dg             |d   r.|j                  t        j                  t        |      g             t        j                  t        j                  |      |      }t        j                  || j                  d         }|j                  d      }|S )an  Split an audio signal into non-silent intervals.

    Parameters
    ----------
    y : np.ndarray, shape=(..., n)
        An audio signal. Multi-channel is supported.
    top_db : number > 0
        The threshold (in decibels) below reference to consider as
        silence
    ref : number or callable
        The reference amplitude.  By default, it uses `np.max` and compares
        to the peak amplitude in the signal.
    frame_length : int > 0
        The number of samples per analysis frame
    hop_length : int > 0
        The number of samples between analysis frames
    aggregate : callable [default: np.max]
        Function to aggregate across channels (if y.ndim > 1)

    Returns
    -------
    intervals : np.ndarray, shape=(m, 2)
        ``intervals[i] == (start_i, end_i)`` are the start and end time
        (in samples) of non-silent interval ``i``.
    r   r   r   r7   r   )r7      )r   rh   r   diffastyperM   insertarrayrk   rl   r   r   rn   minimumr>   reshape)r2   ru   rv   rt   r-   rw   r   edgess           rC   r"   r"     s    D ,	!J NN277:#4#4S#9:;E QYKE !}Q!& "~RXXs:/01 ""2>>%#8ZPE JJuaggbk*E MM'"ELrD   .)coefzi	return_zfr   r   r   c                     y N r2   r   r   r   s       rC   preemphasisr          rD   )r   r   c                     y r   r   r   s       rC   r   r          %(rD   c                     y r   r   r   s       rC   r   r     s     8;rD   g
ףp=
?c          	         t        j                  d| g| j                        }t        j                  dg| j                        }|d| dddf   z  | dddf   z
  }t        j                  |      }t        j
                  j                  ||| t        j                  || j                              \  }}|r||fS |S )a	  Pre-emphasize an audio signal with a first-order differencing filter:

        y[n] -> y[n] - coef * y[n-1]

    Parameters
    ----------
    y : np.ndarray [shape=(..., n)]
        Audio signal. Multi-channel is supported.

    coef : positive number
        Pre-emphasis coefficient.  Typical values of ``coef`` are between 0 and 1.

        At the limit ``coef=0``, the signal is unchanged.

        At ``coef=1``, the result is the first-order difference of the signal.

        The default (0.97) matches the pre-emphasis filter used in the HTK
        implementation of MFCCs [#]_.

        .. [#] https://htk.eng.cam.ac.uk/

    zi : number
        Initial filter state.  When making successive calls to non-overlapping
        frames, this can be set to the ``zf`` returned from the previous call.
        (See example below.)

        By default ``zi`` is initialized as ``2*y[0] - y[1]``.

    return_zf : boolean
        If ``True``, return the final filter state.
        If ``False``, only return the pre-emphasized signal.

    Returns
    -------
    y_out : np.ndarray
        pre-emphasized signal
    zf : number
        if ``return_zf=True``, the final filter state is also returned

    Examples
    --------
    Apply a standard pre-emphasis filter

    >>> import matplotlib.pyplot as plt
    >>> y, sr = librosa.load(librosa.ex('trumpet'))
    >>> y_filt = librosa.effects.preemphasis(y)
    >>> # and plot the results for comparison
    >>> S_orig = librosa.amplitude_to_db(np.abs(librosa.stft(y)), ref=np.max, top_db=None)
    >>> S_preemph = librosa.amplitude_to_db(np.abs(librosa.stft(y_filt)), ref=np.max, top_db=None)
    >>> fig, ax = plt.subplots(nrows=2, sharex=True, sharey=True)
    >>> librosa.display.specshow(S_orig, y_axis='log', x_axis='time', ax=ax[0])
    >>> ax[0].set(title='Original signal')
    >>> ax[0].label_outer()
    >>> img = librosa.display.specshow(S_preemph, y_axis='log', x_axis='time', ax=ax[1])
    >>> ax[1].set(title='Pre-emphasized signal')
    >>> fig.colorbar(img, ax=ax, format="%+2.f dB")

    Apply pre-emphasis in pieces for block streaming.  Note that the second block
    initializes ``zi`` with the final state ``zf`` returned by the first call.

    >>> y_filt_1, zf = librosa.effects.preemphasis(y[:1000], return_zf=True)
    >>> y_filt_2, zf = librosa.effects.preemphasis(y[1000:], zi=zf, return_zf=True)
    >>> np.allclose(y_filt, np.concatenate([y_filt_1, y_filt_2]))
    True

    See Also
    --------
    deemphasis
    r%   r9   r   .r   r   r   )rh   r   r9   
atleast_1dscipysignallfilter)r2   r   r   r   baro   z_fs           rC   r   r     s    X 	

C$<qww/A


C5(A	z3!8_qac{*	r	B
 %%aA"**Rqww2O%PJE3czLrD   c                     y r   r   r   s       rC   
deemphasisr     r   rD   c                     y r   r   r   s       rC   r   r     r   rD   c                   t        j                  d| g| j                        }t        j                  dg| j                        }|t        j                  t	        | j
                  dd       dgz   | j                        }t        j                  j                  ||| |      \  }}|d|z
  | dd	df   z  | dddf   z
  d
|z
  z  |t        j                  | j
                  d         z  z  z  }nTt        j                  |      }t        j                  j                  ||| |j                  | j                              \  }}|r||fS |S )a  De-emphasize an audio signal with the inverse operation of preemphasis():

    If y = preemphasis(x, coef=coef, zi=zi), the deemphasis is:

    >>> x[i] = y[i] + coef * x[i-1]
    >>> x = deemphasis(y, coef=coef, zi=zi)

    Parameters
    ----------
    y : np.ndarray [shape=(..., n)]
        Audio signal. Multi-channel is supported.

    coef : positive number
        Pre-emphasis coefficient.  Typical values of ``coef`` are between 0 and 1.

        At the limit ``coef=0``, the signal is unchanged.

        At ``coef=1``, the result is the first-order difference of the signal.

        The default (0.97) matches the pre-emphasis filter used in the HTK
        implementation of MFCCs [#]_.

        .. [#] https://htk.eng.cam.ac.uk/

    zi : number
        Initial filter state. If inverting a previous preemphasis(), the same value should be used.

        By default ``zi`` is initialized as
        ``((2 - coef) * y[0] - y[1]) / (3 - coef)``. This
        value corresponds to the transformation of the default initialization of ``zi`` in ``preemphasis()``,
        ``2*x[0] - x[1]``.

    return_zf : boolean
        If ``True``, return the final filter state.
        If ``False``, only return the pre-emphasized signal.

    Returns
    -------
    y_out : np.ndarray
        de-emphasized signal
    zf : number
        if ``return_zf=True``, the final filter state is also returned

    Examples
    --------
    Apply a standard pre-emphasis filter and invert it with de-emphasis

    >>> y, sr = librosa.load(librosa.ex('trumpet'))
    >>> y_filt = librosa.effects.preemphasis(y)
    >>> y_deemph = librosa.effects.deemphasis(y_filt)
    >>> np.allclose(y, y_deemph)
    True

    See Also
    --------
    preemphasis
    r%   r   Nr7   r   r   r   .r      )rh   r   r9   rq   listr>   r   r   r   aranger   r   )r2   r   r   r   r   r   ro   zfs           rC   r   r     s6   @ 	#uQWW-A
#agg&A 
zXXd1773B<(A3.agg>LL((AqR(8	r 	$h!C1H+%#qs(34xryy--/	
 ]]2LL((AqRYYqww5G(H	rbyrD   )4__doc__numpyrh   scipy.signalr    r   r   r   r   util.exceptionsr   typingr	   r
   r   r   r   r   r   r   typing_extensionsr   numpy.typingr   _typingr   r   r   r   r   r   r   r   __all__ndarrayr^   boolrM   r   r   r   r   strr   r    maxr   r!   r"   r   r   r   rD   rC   <module>r      sx  B       + R R R % "	 	 		" 	 	 $ $ '!a	zza U;34d;6GGa a a u]M9:D<OOa a a a a a  !a" 2::rzz!"#aR 	 	 $ $ '!S	zzS U;34d;6GGS S S u]M9:D<OOS S S S S S  !S" ZZ#Sv 	 	 $ $ '!S	zzS U;34d;6GGS S S u]M9:D<OOS S S S S S  !S" ZZ#Sl:BJJ : :# :"** :D W6	zzW6 	W6 	W6
 W6 W6 W6 W6 ZZW6v QU=*	zz=*&uS#X7=*IM=*ZZ=*D "$&&&&5	zz55 5 	5
 
x	5 5 ZZ5v "$&&&&S:	zzS: S: 
uh		S:
 S: S: S: 2::rzz!"S:r "$&&&&C	zzC C 
uh		C
 C C C ZZCL 
 ! #	zz  		
 u~ ZZ 
 
 !	(	zz( ( 		(
 t}( 2::rzz!"( 
( 
 !	;	zz; ; 		;
 ; 2::uRZZ3445; 
; "]	zz] ] 		]
 ] 2::uRZZ3445]@ 
 ! #	zz  		
 u~ ZZ 
 
 !	(	zz( ( 		(
 t}( 2::rzz!"( 
( "X	zzX X 		X
 X 2::uRZZ3445XrD   