pywavelet 0.0.5__py3-none-any.whl → 0.1.1__py3-none-any.whl

pywavelet/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.5'
-__version_tuple__ = version_tuple = (0, 0, 5)
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)

pywavelet/logger.py

@@ -1,11 +1,15 @@
+import logging
 import sys
 import warnings
+
 from rich.logging import RichHandler
-import logging
 
 FORMAT = "%(message)s"
 logging.basicConfig(
-    level="INFO", format=FORMAT, datefmt="[%X]", handlers=[RichHandler(rich_tracebacks=True)]
+    level="INFO",
+    format=FORMAT,
+    datefmt="[%X]",
+    handlers=[RichHandler(rich_tracebacks=True)],
 )
 
 logger = logging.getLogger("pywavelet")

pywavelet/transforms/__init__.py

@@ -1,4 +1,4 @@
-from .forward import from_freq_to_wavelet, from_time_to_wavelet, compute_bins
+from .forward import from_freq_to_wavelet, from_time_to_wavelet
 from .inverse import from_wavelet_to_freq, from_wavelet_to_time
 
 __all__ = [
@@ -6,5 +6,4 @@ __all__ = [
     "from_wavelet_to_freq",
     "from_time_to_wavelet",
     "from_freq_to_wavelet",
-    "compute_bins",
 ]

pywavelet/transforms/forward/__init__.py

@@ -1,4 +1,3 @@
 from .main import from_freq_to_wavelet, from_time_to_wavelet
-from .wavelet_bins import compute_bins
 
-__all__ = ["from_time_to_wavelet", "from_freq_to_wavelet", "compute_bins"]
+__all__ = ["from_time_to_wavelet", "from_freq_to_wavelet"]

pywavelet/transforms/forward/from_freq.py

@@ -1,8 +1,10 @@
 """helper functions for transform_freq"""
+
 import numpy as np
 from numba import njit
 from numpy import fft
 
+
 def transform_wavelet_freq_helper(
     data: np.ndarray, Nf: int, Nt: int, phif: np.ndarray
 ) -> np.ndarray:
@@ -13,8 +15,16 @@ def transform_wavelet_freq_helper(
     __core(Nf, Nt, DX, freq_strain, phif, wave)
     return wave
 
+
 # @njit()
-def __core(Nf:int, Nt:int, DX:np.ndarray, freq_strain:np.ndarray, phif:np.ndarray, wave:np.ndarray):
+def __core(
+    Nf: int,
+    Nt: int,
+    DX: np.ndarray,
+    freq_strain: np.ndarray,
+    phif: np.ndarray,
+    wave: np.ndarray,
+):
     for f_bin in range(0, Nf + 1):
         __fill_wave_1(f_bin, Nt, Nf, DX, freq_strain, phif)
         # Numba doesn't support np.ifft so we cant jit this
@@ -22,8 +32,6 @@ def __core(Nf:int, Nt:int, DX:np.ndarray, freq_strain:np.ndarray, phif:np.ndarra
         __fill_wave_2(f_bin, DX_trans, wave, Nt, Nf)
 
 
-
-
 @njit()
 def __fill_wave_1(
     f_bin: int,
@@ -55,6 +63,7 @@ def __fill_wave_1(
         else:
             DX[i] = phif[j] * data[jj]
 
+
 @njit()
 def __fill_wave_2(
     f_bin: int, DX_trans: np.ndarray, wave: np.ndarray, Nt: int, Nf: int
@@ -72,7 +81,7 @@ def __fill_wave_2(
                 if (n + f_bin) % 2:
                     wave[n, f_bin] = -DX_trans[n].imag
                 else:
-                    wave[n, f_bin] =  DX_trans[n].real
+                    wave[n, f_bin] = DX_trans[n].real
             else:
                 if (n + f_bin) % 2:
                     wave[n, f_bin] = DX_trans[n].imag

pywavelet/transforms/forward/from_time.py

@@ -1,4 +1,5 @@
 """helper functions for transform_time.py"""
+
 import numpy as np
 from numba import njit
 from numpy import fft
@@ -20,7 +21,18 @@ def transform_wavelet_time_helper(
     __core(Nf, Nt, K, ND, wdata, data_pad, phi, wave, mult)
     return wave
 
-def __core(Nf: int, Nt: int, K: int, ND: int, wdata: np.ndarray, data_pad: np.ndarray, phi: np.ndarray, wave: np.ndarray, mult: int) -> None:
+
+def __core(
+    Nf: int,
+    Nt: int,
+    K: int,
+    ND: int,
+    wdata: np.ndarray,
+    data_pad: np.ndarray,
+    phi: np.ndarray,
+    wave: np.ndarray,
+    mult: int,
+) -> None:
     for time_bin_i in range(0, Nt):
         __fill_wave_1(time_bin_i, K, ND, Nf, wdata, data_pad, phi)
         wdata_trans = np.fft.rfft(wdata, K)

pywavelet/transforms/forward/main.py

@@ -3,15 +3,15 @@ from typing import Union
 import numpy as np
 
 from ...logger import logger
+from ...types import FrequencySeries, TimeSeries, Wavelet
+from ...types.wavelet_bins import _get_bins, _preprocess_bins
 from ..phi_computer import phi_vec, phitilde_vec_norm
-from ..types import FrequencySeries, TimeSeries, Wavelet
 from .from_freq import transform_wavelet_freq_helper
 from .from_time import transform_wavelet_time_helper
-from .wavelet_bins import _get_bins, _preprocess_bins
-
 
 __all__ = ["from_time_to_wavelet", "from_freq_to_wavelet"]
 
+
 def from_time_to_wavelet(
     timeseries: TimeSeries,
     Nf: Union[int, None] = None,
@@ -74,9 +74,7 @@ def from_time_to_wavelet(
     mult = min(mult, Nt // 2)  # Ensure mult is not larger than ND/2
     phi = phi_vec(Nf, dt=dt, d=nx, q=mult)
     wave = transform_wavelet_time_helper(timeseries.data, Nf, Nt, phi, mult).T
-    return Wavelet(
-        wave * np.sqrt(2), time=t_bins, freq=f_bins
-    )
+    return Wavelet(wave * np.sqrt(2), time=t_bins, freq=f_bins)
 
 
 def from_freq_to_wavelet(
@@ -117,12 +115,6 @@ def from_freq_to_wavelet(
     t_bins, f_bins = _get_bins(freqseries, Nf, Nt)
     dt = freqseries.dt
     phif = phitilde_vec_norm(Nf, Nt, dt=dt, d=nx)
-    wave = transform_wavelet_freq_helper(
-        freqseries.data, Nf, Nt, phif
-    )
-
-    return Wavelet(
-        (2 / Nf) * wave.T * np.sqrt(2),
-        time=t_bins,
-        freq=f_bins
-    )
+    wave = transform_wavelet_freq_helper(freqseries.data, Nf, Nt, phif)
+
+    return Wavelet((2 / Nf) * wave.T * np.sqrt(2), time=t_bins, freq=f_bins)

pywavelet/transforms/inverse/main.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from ...transforms.phi_computer import phi_vec, phitilde_vec_norm
-from ..types import FrequencySeries, TimeSeries, Wavelet
+from ...types import FrequencySeries, TimeSeries, Wavelet
 from .to_freq import inverse_wavelet_freq_helper_fast
 from .to_time import inverse_wavelet_time_helper_fast
 
@@ -9,6 +9,7 @@ __all__ = ["from_wavelet_to_time", "from_wavelet_to_freq"]
 
 INV_ROOT2 = 1.0 / np.sqrt(2)
 
+
 def from_wavelet_to_time(
     wave_in: Wavelet,
     dt: float,
@@ -55,9 +56,7 @@ def from_wavelet_to_time(
 
 
 def from_wavelet_to_freq(
-    wave_in: Wavelet,
-    dt: float,
-    nx:float=4.0
+    wave_in: Wavelet, dt: float, nx: float = 4.0
 ) -> FrequencySeries:
     """
     Perform an inverse wavelet transform to the frequency domain.

pywavelet/transforms/inverse/to_freq.py

@@ -1,4 +1,5 @@
 """functions for computing the inverse wavelet transforms"""
+
 import numpy as np
 from numba import njit
 from numpy import fft
@@ -12,13 +13,20 @@ def inverse_wavelet_freq_helper_fast(
     ND = Nf * Nt
 
     prefactor2s = np.zeros(Nt, np.complex128)
-    res = np.zeros(ND//2 +1, dtype=np.complex128)
+    res = np.zeros(ND // 2 + 1, dtype=np.complex128)
     __core(Nf, Nt, prefactor2s, wave_in, phif, res)
 
-
     return res
 
-def __core(Nf: int, Nt: int, prefactor2s: np.ndarray, wave_in: np.ndarray, phif: np.ndarray, res: np.ndarray) -> None:
+
+def __core(
+    Nf: int,
+    Nt: int,
+    prefactor2s: np.ndarray,
+    wave_in: np.ndarray,
+    phif: np.ndarray,
+    res: np.ndarray,
+) -> None:
     for m in range(0, Nf + 1):
         __pack_wave_inverse(m, Nt, Nf, prefactor2s, wave_in)
         fft_prefactor2s = np.fft.fft(prefactor2s)

pywavelet/transforms/inverse/to_time.py

@@ -1,4 +1,5 @@
 """functions for computing the inverse wavelet transforms"""
+
 import numpy as np
 from numba import njit
 from numpy import fft
@@ -21,7 +22,16 @@ def inverse_wavelet_time_helper_fast(
     return res[:ND]
 
 
-def __core(Nf: int, Nt: int, K: int, ND: int, wave_in: np.ndarray, phi: np.ndarray, res: np.ndarray, afins:np.ndarray) -> None:
+def __core(
+    Nf: int,
+    Nt: int,
+    K: int,
+    ND: int,
+    wave_in: np.ndarray,
+    phi: np.ndarray,
+    res: np.ndarray,
+    afins: np.ndarray,
+) -> None:
     for n in range(0, Nt):
         if n % 2 == 0:
             pack_wave_time_helper_compact(n, Nf, Nt, wave_in, afins)
@@ -29,9 +39,9 @@ def __core(Nf: int, Nt: int, K: int, ND: int, wave_in: np.ndarray, phi: np.ndarr
             unpack_time_wave_helper_compact(n, Nf, Nt, K, phi, ffts_fin, res)
 
     # wrap boundary conditions
-    res[: min(K + Nf, ND)] += res[ND: min(ND + K + Nf, 2 * ND)]
+    res[: min(K + Nf, ND)] += res[ND : min(ND + K + Nf, 2 * ND)]
     if K + Nf > ND:
-        res[: K + Nf - ND] += res[2 * ND: ND + K * Nf]
+        res[: K + Nf - ND] += res[2 * ND : ND + K * Nf]
 
 
 def unpack_time_wave_helper(

pywavelet/{transforms/types → types}/__init__.py

@@ -1,3 +1,3 @@
 from .frequencyseries import FrequencySeries
 from .timeseries import TimeSeries
-from .wavelet import Wavelet
+from .wavelet import Wavelet, WaveletMask

pywavelet/{transforms/types → types}/common.py

@@ -1,9 +1,9 @@
-from typing import Literal, Tuple
+from typing import Tuple, Union
 
 import numpy as xp
-from numpy.fft import irfft, fft, rfft, rfftfreq
+from numpy.fft import fft, irfft, rfft, rfftfreq  # type: ignore
 
-from ...logger import logger
+from ..logger import logger
 
 
 def _len_check(d):
@@ -19,7 +19,7 @@ def is_documented_by(original):
     return wrapper
 
 
-def fmt_time(seconds: float, units=False) -> Tuple[str, str]:
+def fmt_time(seconds: float, units=False) -> Union[str, Tuple[str, str]]:
     """Returns formatted time and units [ms, s, min, hr, day]"""
     t, u = "", ""
     if seconds < 1e-3:
@@ -42,12 +42,12 @@ def fmt_time(seconds: float, units=False) -> Tuple[str, str]:
 
 def fmt_timerange(trange):
     t0 = fmt_time(trange[0])
-    tend, units = fmt_time(trange[1], units = True)
+    tend, units = fmt_time(trange[1], units=True)
     return f"[{t0}, {tend}] {units}"
 
 
-def fmt_pow2(n:float)->str:
+def fmt_pow2(n: float) -> str:
     pow2 = xp.log2(n)
     if pow2.is_integer():
         return f"2^{int(pow2)}"
-    return f"{n:,}"
+    return f"{n:,}"

pywavelet/{transforms/types → types}/frequencyseries.py

@@ -1,11 +1,13 @@
+from typing import Optional, Tuple, Union
+
 import matplotlib.pyplot as plt
-from typing import Tuple, Union, Optional
 
-from .common import is_documented_by, xp, irfft, fmt_time, fmt_pow2
+from .common import fmt_pow2, fmt_time, irfft, is_documented_by, xp
 from .plotting import plot_freqseries, plot_periodogram
 
 __all__ = ["FrequencySeries"]
 
+
 class FrequencySeries:
     """
     A class to represent a one-sided frequency series, with various methods for
@@ -39,9 +41,13 @@ class FrequencySeries:
             If any frequency is negative or if `data` and `freq` do not have the same length.
         """
         if xp.any(freq < 0):
-            raise ValueError("FrequencySeries must be one-sided (only non-negative frequencies)")
+            raise ValueError(
+                "FrequencySeries must be one-sided (only non-negative frequencies)"
+            )
         if len(data) != len(freq):
-            raise ValueError(f"data and freq must have the same length ({len(data)} != {len(freq)})")
+            raise ValueError(
+                f"data and freq must have the same length ({len(data)} != {len(freq)})"
+            )
         self.data = data
         self.freq = freq
         self.t0 = t0
@@ -53,10 +59,10 @@ class FrequencySeries:
         )
 
     @is_documented_by(plot_periodogram)
-    def plot_periodogram(self, ax=None, **kwargs) -> Tuple[plt.Figure, plt.Axes]:
-        return plot_periodogram(
-            self.data, self.freq, self.fs, ax=ax, **kwargs
-        )
+    def plot_periodogram(
+        self, ax=None, **kwargs
+    ) -> Tuple[plt.Figure, plt.Axes]:
+        return plot_periodogram(self.data, self.freq, self.fs, ax=ax, **kwargs)
 
     def __len__(self):
         """Return the length of the frequency series."""
@@ -127,7 +133,9 @@ class FrequencySeries:
         n = fmt_pow2(len(self))
         return f"FrequencySeries(n={n}, frange=[{self.range[0]:.2f}, {self.range[1]:.2f}] Hz, T={dur}, fs={self.fs:.2f} Hz)"
 
-    def noise_weighted_inner_product(self, other: "FrequencySeries", psd:"FrequencySeries") -> float:
+    def noise_weighted_inner_product(
+        self, other: "FrequencySeries", psd: "FrequencySeries"
+    ) -> float:
         """
         Compute the noise-weighted inner product of two FrequencySeries.
 
@@ -144,9 +152,11 @@ class FrequencySeries:
             The noise-weighted inner product of the two FrequencySeries.
         """
         integrand = xp.real(xp.conj(self.data) * other.data / psd.data)
-        return (4 * self.dt/self.ND) * xp.nansum(integrand)
+        return (4 * self.dt / self.ND) * xp.nansum(integrand)
 
-    def matched_filter_snr(self, other: "FrequencySeries", psd: "FrequencySeries") -> float:
+    def matched_filter_snr(
+        self, other: "FrequencySeries", psd: "FrequencySeries"
+    ) -> float:
         """
         Compute the signal-to-noise ratio (SNR) of a matched filter.
 
@@ -199,15 +209,15 @@ class FrequencySeries:
 
         # Create and return a TimeSeries object
         from .timeseries import TimeSeries
-        return TimeSeries(time_data, time)
 
+        return TimeSeries(time_data, time)
 
     def to_wavelet(
-            self,
-            Nf: Union[int, None] = None,
-            Nt: Union[int, None] = None,
-            nx: Optional[float] = 4.0,
-        )->"Wavelet":
+        self,
+        Nf: Union[int, None] = None,
+        Nt: Union[int, None] = None,
+        nx: Optional[float] = 4.0,
+    ) -> "Wavelet":
         """
         Convert the frequency series to a wavelet using inverse Fourier transform.
 
@@ -216,9 +226,9 @@ class FrequencySeries:
         Wavelet
             The corresponding wavelet.
         """
-        from ..forward import from_freq_to_wavelet
-        return from_freq_to_wavelet(self, Nf=Nf, Nt=Nt, nx=nx)
+        from ..transforms.forward import from_freq_to_wavelet
 
+        return from_freq_to_wavelet(self, Nf=Nf, Nt=Nt, nx=nx)
 
     def __eq__(self, other):
         """Check if two FrequencySeries objects are equal."""
@@ -228,10 +238,8 @@ class FrequencySeries:
 
     def __copy__(self):
         return FrequencySeries(
-            xp.copy(self.data),
-            xp.copy(self.freq),
-            t0=self.t0
+            xp.copy(self.data), xp.copy(self.freq), t0=self.t0
         )
 
     def copy(self):
-        return self.__copy__()
+        return self.__copy__()

pywavelet/{transforms/types → types}/plotting.py

@@ -1,12 +1,11 @@
 import warnings
-from typing import Tuple, Optional, Union
-from scipy.signal import savgol_filter
-from scipy.interpolate import interp1d
+from typing import Optional, Tuple, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib.colors import LogNorm, TwoSlopeNorm
-from scipy.signal import spectrogram
+from scipy.interpolate import interp1d
+from scipy.signal import savgol_filter, spectrogram
 
 MIN_S = 60
 HOUR_S = 60 * MIN_S
@@ -53,8 +52,13 @@ def __get_smoothed_y(x, z, y_grid):
         # Interpolate to fill NaNs in y before smoothing
         nan_mask = ~np.isnan(y)
         if np.isnan(y).any():
-            interpolator = interp1d(x[nan_mask], y[nan_mask], kind='cubic', bounds_error=False,
-                                    fill_value="extrapolate")
+            interpolator = interp1d(
+                x[nan_mask],
+                y[nan_mask],
+                kind="cubic",
+                bounds_error=False,
+                fill_value="extrapolate",
+            )
             y = interpolator(x)  # Fill NaNs with interpolated values
 
         # Smooth the curve
@@ -64,8 +68,6 @@ def __get_smoothed_y(x, z, y_grid):
     return y
 
 
-
-
 def plot_wavelet_grid(
     wavelet_data: np.ndarray,
     time_grid: np.ndarray,
@@ -80,8 +82,8 @@ def plot_wavelet_grid(
     norm: Optional[Union[LogNorm, TwoSlopeNorm]] = None,
     cbar_label: Optional[str] = None,
     nan_color: Optional[str] = "black",
-    detailed_axes:bool = False,
-    show_gridinfo:bool = True,
+    detailed_axes: bool = False,
+    show_gridinfo: bool = True,
     trend_color: Optional[str] = None,
     whiten_by: Optional[np.ndarray] = None,
     **kwargs,
@@ -153,7 +155,9 @@ def plot_wavelet_grid(
 
     # Validate the dimensions
     if (Nf, Nt) != (len(freq_grid), len(time_grid)):
-        raise ValueError(f"Wavelet shape {Nf, Nt} does not match provided grids {(len(freq_grid), len(time_grid))}.")
+        raise ValueError(
+            f"Wavelet shape {Nf, Nt} does not match provided grids {(len(freq_grid), len(time_grid))}."
+        )
 
     # Prepare the data for plotting
     z = wavelet_data.copy()
@@ -162,14 +166,15 @@ def plot_wavelet_grid(
     if absolute:
         z = np.abs(z)
 
-
     # Determine normalization and colormap
     if norm is None:
         try:
             if np.all(np.isnan(z)):
                 raise ValueError("All wavelet data is NaN.")
             if zscale == "log":
-                norm = LogNorm(vmin=np.nanmin(z[z > 0]), vmax=np.nanmax(z[z<np.inf]))
+                norm = LogNorm(
+                    vmin=np.nanmin(z[z > 0]), vmax=np.nanmax(z[z < np.inf])
+                )
             elif not absolute:
                 vmin, vmax = np.nanmin(z), np.nanmax(z)
                 vcenter = 0.0
@@ -177,7 +182,9 @@ def plot_wavelet_grid(
             else:
                 norm = None  # Default linear scaling
         except Exception as e:
-            warnings.warn(f"Error in determining normalization: {e}. Using default linear scaling.")
+            warnings.warn(
+                f"Error in determining normalization: {e}. Using default linear scaling."
+            )
             norm = None
 
     if cmap is None:
@@ -195,7 +202,7 @@ def plot_wavelet_grid(
     im = ax.imshow(
         z,
         aspect="auto",
-        extent=[time_grid[0],time_grid[-1], freq_grid[0], freq_grid[-1]],
+        extent=[time_grid[0], time_grid[-1], freq_grid[0], freq_grid[-1]],
         origin="lower",
         cmap=cmap,
         norm=norm,
@@ -203,13 +210,25 @@ def plot_wavelet_grid(
         **kwargs,
     )
     if trend_color is not None:
-        plot_wavelet_trend(wavelet_data, time_grid, freq_grid, ax, color=trend_color, freq_range=freq_range, freq_scale=freq_scale)
+        plot_wavelet_trend(
+            wavelet_data,
+            time_grid,
+            freq_grid,
+            ax,
+            color=trend_color,
+            freq_range=freq_range,
+            freq_scale=freq_scale,
+        )
 
     # Add colorbar if requested
     if show_colorbar:
         cbar = fig.colorbar(im, ax=ax)
         if cbar_label is None:
-            cbar_label = "Absolute Wavelet Amplitude" if absolute else "Wavelet Amplitude"
+            cbar_label = (
+                "Absolute Wavelet Amplitude"
+                if absolute
+                else "Wavelet Amplitude"
+            )
         cbar.set_label(cbar_label)
 
     # Configure axes scales
@@ -239,14 +258,12 @@ def plot_wavelet_grid(
             bbox=dict(boxstyle="round", facecolor=None, alpha=0.2),
         )
 
-
     # Adjust layout
     fig.tight_layout()
 
     return fig, ax
 
 
-
 def plot_freqseries(
     data: np.ndarray,
     freq: np.ndarray,
@@ -277,9 +294,10 @@ def plot_periodogram(
     flow = np.min(np.abs(freq))
     ax.set_xlabel("Frequency [Hz]")
     ax.set_ylabel("Periodigram")
-    ax.set_xlim(left=flow, right=nyquist_frequency/2)
+    ax.set_xlim(left=flow, right=nyquist_frequency / 2)
     return ax.figure, ax
 
+
 def plot_timeseries(
     data: np.ndarray, time: np.ndarray, ax=None, **kwargs
 ) -> Tuple[plt.Figure, plt.Axes]:
@@ -314,7 +332,6 @@ def plot_spectrogram(
 
     _fmt_time_axis(t, ax)
 
-
     ax.set_ylabel("Frequency [Hz]")
     ax.set_ylim(top=fs / 2.0)
     cbar = plt.colorbar(cm, ax=ax)
@@ -322,20 +339,24 @@ def plot_spectrogram(
     return ax.figure, ax
 
 
-
 def _fmt_time_axis(t, axes, t0=None, tmax=None):
     if t[-1] > DAY_S:  # If time goes beyond a day
-        axes.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x / DAY_S:.1f}"))
+        axes.xaxis.set_major_formatter(
+            plt.FuncFormatter(lambda x, _: f"{x / DAY_S:.1f}")
+        )
         axes.set_xlabel("Time [days]")
     elif t[-1] > HOUR_S:  # If time goes beyond an hour
-        axes.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x / HOUR_S:.1f}"))
+        axes.xaxis.set_major_formatter(
+            plt.FuncFormatter(lambda x, _: f"{x / HOUR_S:.1f}")
+        )
         axes.set_xlabel("Time [hr]")
     elif t[-1] > MIN_S:  # If time goes beyond a minute
-        axes.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x / MIN_S:.1f}"))
+        axes.xaxis.set_major_formatter(
+            plt.FuncFormatter(lambda x, _: f"{x / MIN_S:.1f}")
+        )
         axes.set_xlabel("Time [min]")
     else:
         axes.set_xlabel("Time [s]")
     t0 = t[0] if t0 is None else t0
     tmax = t[-1] if tmax is None else tmax
     axes.set_xlim(t0, tmax)
-

pywavelet/{transforms/types → types}/timeseries.py

@@ -1,11 +1,20 @@
+from typing import Optional, Tuple, Union
+
 import matplotlib.pyplot as plt
-from typing import Tuple, Optional, Union
-from scipy.signal.windows import tukey
 from scipy.signal import butter, sosfiltfilt
+from scipy.signal.windows import tukey
 
-from ...logger import logger
-from .common import is_documented_by, xp, rfft, rfftfreq, fmt_timerange, fmt_time, fmt_pow2
-from .plotting import plot_timeseries, plot_spectrogram
+from ..logger import logger
+from .common import (
+    fmt_pow2,
+    fmt_time,
+    fmt_timerange,
+    is_documented_by,
+    rfft,
+    rfftfreq,
+    xp,
+)
+from .plotting import plot_spectrogram, plot_timeseries
 
 __all__ = ["TimeSeries"]
 
@@ -50,7 +59,7 @@ class TimeSeries:
 
     @is_documented_by(plot_spectrogram)
     def plot_spectrogram(
-            self, ax=None, spec_kwargs={}, plot_kwargs={}
+        self, ax=None, spec_kwargs={}, plot_kwargs={}
     ) -> Tuple[plt.Figure, plt.Axes]:
         return plot_spectrogram(
             self.data,
@@ -122,9 +131,11 @@ class TimeSeries:
         trange = fmt_timerange((self.t0, self.tend))
         T = " ".join(fmt_time(self.duration, units=True))
         n = fmt_pow2(len(self))
-        return f"TimeSeries(n={n}, trange={trange}, T={T}, fs={self.fs:.2f} Hz)"
+        return (
+            f"TimeSeries(n={n}, trange={trange}, T={T}, fs={self.fs:.2f} Hz)"
+        )
 
-    def to_frequencyseries(self) -> 'FrequencySeries':
+    def to_frequencyseries(self) -> "FrequencySeries":
         """
         Convert the time series to a frequency series using the one-sided FFT.
 
@@ -137,14 +148,15 @@ class TimeSeries:
         data = rfft(self.data)
 
         from .frequencyseries import FrequencySeries  # Avoid circular import
+
         return FrequencySeries(data, freq, t0=self.t0)
 
     def to_wavelet(
-            self,
-            Nf: Union[int, None] = None,
-            Nt: Union[int, None] = None,
-            nx: Optional[float] = 4.0,
-    ) -> 'Wavelet':
+        self,
+        Nf: Union[int, None] = None,
+        Nt: Union[int, None] = None,
+        nx: Optional[float] = 4.0,
+    ) -> "Wavelet":
         """
         Convert the time series to a wavelet representation.
 
@@ -166,32 +178,37 @@ class TimeSeries:
         hf = self.to_frequencyseries()
         return hf.to_wavelet(Nf, Nt, nx=nx)
 
-
-    def __add__(self, other: 'TimeSeries') -> 'TimeSeries':
+    def __add__(self, other: "TimeSeries") -> "TimeSeries":
         """Add two TimeSeries objects together."""
         if self.shape != other.shape:
-            raise ValueError("TimeSeries objects must have the same shape to add them together")
+            raise ValueError(
+                "TimeSeries objects must have the same shape to add them together"
+            )
         return TimeSeries(self.data + other.data, self.time)
 
-    def __sub__(self, other: 'TimeSeries') -> 'TimeSeries':
+    def __sub__(self, other: "TimeSeries") -> "TimeSeries":
         """Subtract one TimeSeries object from another."""
         if self.shape != other.shape:
-            raise ValueError("TimeSeries objects must have the same shape to subtract them")
+            raise ValueError(
+                "TimeSeries objects must have the same shape to subtract them"
+            )
         return TimeSeries(self.data - other.data, self.time)
 
-    def __eq__(self, other: 'TimeSeries') -> bool:
+    def __eq__(self, other: "TimeSeries") -> bool:
         """Check if two TimeSeries objects are equal."""
         shape_same = self.shape == other.shape
         range_same = self.t0 == other.t0 and self.tend == other.tend
-        time_same =  xp.allclose(self.time, other.time)
+        time_same = xp.allclose(self.time, other.time)
         data_same = xp.allclose(self.data, other.data)
         return shape_same and range_same and data_same and time_same
 
-    def __mul__(self, other: float) -> 'TimeSeries':
+    def __mul__(self, other: float) -> "TimeSeries":
         """Multiply a TimeSeries object by a scalar."""
         return TimeSeries(self.data * other, self.time)
 
-    def zero_pad_to_power_of_2(self, tukey_window_alpha:float=0.0)->'TimeSeries':
+    def zero_pad_to_power_of_2(
+        self, tukey_window_alpha: float = 0.0
+    ) -> "TimeSeries":
         """Zero pad the time series to make the length a power of two (useful to speed up FFTs, O(NlogN) versus O(N^2)).
 
         Parameters
@@ -207,7 +224,7 @@ class TimeSeries:
         """
         N, dt, t0 = self.ND, self.dt, self.t0
         pow_2 = xp.ceil(xp.log2(N))
-        n_pad = int((2 ** pow_2) - N)
+        n_pad = int((2**pow_2) - N)
         new_N = N + n_pad
         if n_pad > 0:
             logger.warning(
@@ -220,7 +237,12 @@ class TimeSeries:
         time = xp.arange(0, len(data) * dt, dt) + t0
         return TimeSeries(data, time)
 
-    def highpass_filter(self, fmin: float, tukey_window_alpha:float=0.0, bandpass_order: int = 4) -> 'TimeSeries':
+    def highpass_filter(
+        self,
+        fmin: float,
+        tukey_window_alpha: float = 0.0,
+        bandpass_order: int = 4,
+    ) -> "TimeSeries":
         """
         Filter the time series with a highpass bandpass filter.
 
@@ -244,24 +266,25 @@ class TimeSeries:
         """
 
         if fmin <= 0 or fmin > self.nyquist_frequency:
-            raise ValueError(f"Invalid fmin value: {fmin}. Must be in the range [0, {self.nyquist_frequency}]")
+            raise ValueError(
+                f"Invalid fmin value: {fmin}. Must be in the range [0, {self.nyquist_frequency}]"
+            )
 
-        sos = butter(bandpass_order, Wn=fmin, btype="highpass", output='sos', fs=self.fs)
+        sos = butter(
+            bandpass_order, Wn=fmin, btype="highpass", output="sos", fs=self.fs
+        )
         window = tukey(self.ND, alpha=tukey_window_alpha)
         data = self.data.copy()
         data = sosfiltfilt(sos, data * window)
         return TimeSeries(data, self.time)
 
     def __copy__(self):
-        return TimeSeries(
-            self.data.copy(),
-            self.time.copy()
-        )
+        return TimeSeries(self.data.copy(), self.time.copy())
 
     def copy(self):
         return self.__copy__()
 
-    def __getitem__(self, key)->"TimeSeries":
+    def __getitem__(self, key) -> "TimeSeries":
         if isinstance(key, slice):
             # Handle slicing
             return self.__handle_slice(key)
@@ -269,12 +292,9 @@ class TimeSeries:
             # Handle regular indexing
             return TimeSeries(self.data[key], self.time[key])
 
-    def __handle_slice(self, slice_obj)->"TimeSeries":
-        return TimeSeries(
-            self.data[slice_obj],
-            self.time[slice_obj]
-        )
+    def __handle_slice(self, slice_obj) -> "TimeSeries":
+        return TimeSeries(self.data[slice_obj], self.time[slice_obj])
 
     @classmethod
-    def _EMPTY(cls, ND:int, dt:float)->"TimeSeries":
-        return cls(xp.zeros(ND), xp.arange(0, ND*dt, dt))
+    def _EMPTY(cls, ND: int, dt: float) -> "TimeSeries":
+        return cls(xp.zeros(ND), xp.arange(0, ND * dt, dt))

pywavelet/{transforms/types → types}/wavelet.py

@@ -1,10 +1,11 @@
-import matplotlib.pyplot as plt
-from typing import Optional, Tuple
+from typing import List, Optional, Tuple
 
+import matplotlib.pyplot as plt
 import numpy as np
 
-from .common import is_documented_by, xp, fmt_timerange
+from .common import fmt_timerange, is_documented_by, xp
 from .plotting import plot_wavelet_grid, plot_wavelet_trend
+from .wavelet_bins import compute_bins
 
 
 class Wavelet:
@@ -22,10 +23,10 @@ class Wavelet:
     """
 
     def __init__(
-            self,
-            data: xp.ndarray,
-            time: xp.ndarray,
-            freq: xp.ndarray,
+        self,
+        data: xp.ndarray,
+        time: xp.ndarray,
+        freq: xp.ndarray,
     ):
         """
         Initialize the Wavelet object with data, time, and frequency arrays.
@@ -53,17 +54,60 @@ class Wavelet:
         self.time = time
         self.freq = freq
 
+    @classmethod
+    def zeros_from_grid(cls, time: xp.ndarray, freq: xp.ndarray) -> "Wavelet":
+        """
+        Create a Wavelet object filled with zeros.
+
+        Parameters
+        ----------
+        time: xp.ndarray
+        freq: xp.ndarray
+
+        Returns
+        -------
+        Wavelet
+            A Wavelet object with zero-filled data array.
+        """
+        Nf, Nt = len(freq), len(time)
+        return cls(data=xp.zeros((Nf, Nt)), time=time, freq=freq)
+
+    @classmethod
+    def zeros(cls, Nf: int, Nt: int, T: float) -> "Wavelet":
+        """
+        Create a Wavelet object filled with zeros.
+
+        Parameters
+        ----------
+        Nf : int
+            Number of frequency bins.
+        Nt : int
+            Number of time bins.
+
+        Returns
+        -------
+        Wavelet
+            A Wavelet object with zero-filled data array.
+        """
+        return cls.zeros_from_grid(*compute_bins(Nf, Nt, T))
+
     @is_documented_by(plot_wavelet_grid)
     def plot(self, ax=None, *args, **kwargs) -> Tuple[plt.Figure, plt.Axes]:
         kwargs["time_grid"] = kwargs.get("time_grid", self.time)
         kwargs["freq_grid"] = kwargs.get("freq_grid", self.freq)
-        return plot_wavelet_grid(wavelet_data=self.data, ax=ax, *args, **kwargs)
+        return plot_wavelet_grid(
+            wavelet_data=self.data, ax=ax, *args, **kwargs
+        )
 
     @is_documented_by(plot_wavelet_trend)
-    def plot_trend(self, ax=None, *args, **kwargs) -> Tuple[plt.Figure, plt.Axes]:
+    def plot_trend(
+        self, ax=None, *args, **kwargs
+    ) -> Tuple[plt.Figure, plt.Axes]:
         kwargs["time_grid"] = kwargs.get("time_grid", self.time)
         kwargs["freq_grid"] = kwargs.get("freq_grid", self.freq)
-        return plot_wavelet_trend(wavelet_data=self.data, ax=ax, *args, **kwargs)
+        return plot_wavelet_trend(
+            wavelet_data=self.data, ax=ax, *args, **kwargs
+        )
 
     @property
     def Nt(self) -> int:
@@ -242,7 +286,8 @@ class Wavelet:
         TimeSeries
             A `TimeSeries` object representing the time-domain signal.
         """
-        from ..inverse import from_wavelet_to_time
+        from ..transforms.inverse import from_wavelet_to_time
+
         return from_wavelet_to_time(self, dt=self.delta_t, nx=nx, mult=mult)
 
     def to_frequencyseries(self, nx: float = 4.0) -> "FrequencySeries":
@@ -254,7 +299,8 @@ class Wavelet:
         FrequencySeries
             A `FrequencySeries` object representing the frequency-domain signal.
         """
-        from ..inverse import from_wavelet_to_freq
+        from ..transforms.inverse import from_wavelet_to_freq
+
         return from_wavelet_to_freq(self, dt=self.delta_t, nx=nx)
 
     def __repr__(self) -> str:
@@ -277,40 +323,57 @@ class Wavelet:
     def __add__(self, other):
         """Element-wise addition of two Wavelet objects."""
         if isinstance(other, Wavelet):
-            return Wavelet(data=self.data + other.data, time=self.time, freq=self.freq)
+            return Wavelet(
+                data=self.data + other.data, time=self.time, freq=self.freq
+            )
         elif isinstance(other, float):
-            return Wavelet(data=self.data + other, time=self.time, freq=self.freq)
+            return Wavelet(
+                data=self.data + other, time=self.time, freq=self.freq
+            )
 
     def __sub__(self, other):
         """Element-wise subtraction of two Wavelet objects."""
         if isinstance(other, Wavelet):
-            return Wavelet(data=self.data - other.data, time=self.time, freq=self.freq)
+            return Wavelet(
+                data=self.data - other.data, time=self.time, freq=self.freq
+            )
         elif isinstance(other, float):
-            return Wavelet(data=self.data - other, time=self.time, freq=self.freq)
+            return Wavelet(
+                data=self.data - other, time=self.time, freq=self.freq
+            )
 
     def __mul__(self, other):
         """Element-wise multiplication of two Wavelet objects."""
         if isinstance(other, Wavelet):
-            return Wavelet(data=self.data * other.data, time=self.time, freq=self.freq)
+            return Wavelet(
+                data=self.data * other.data, time=self.time, freq=self.freq
+            )
         elif isinstance(other, float):
-            return Wavelet(data=self.data * other, time=self.time, freq=self.freq)
+            return Wavelet(
+                data=self.data * other, time=self.time, freq=self.freq
+            )
 
     def __truediv__(self, other):
         """Element-wise division of two Wavelet objects."""
         if isinstance(other, Wavelet):
-            return Wavelet(data=self.data / other.data, time=self.time, freq=self.freq)
+            return Wavelet(
+                data=self.data / other.data, time=self.time, freq=self.freq
+            )
         elif isinstance(other, float):
-            return Wavelet(data=self.data / other, time=self.time, freq=self.freq)
+            return Wavelet(
+                data=self.data / other, time=self.time, freq=self.freq
+            )
 
-    def __eq__(self, other:"Wavelet") -> bool:
+    def __eq__(self, other: "Wavelet") -> bool:
         """Element-wise comparison of two Wavelet objects."""
         data_all_same = xp.isclose(xp.nansum(self.data - other.data), 0)
         time_same = (self.time == other.time).all()
         freq_same = (self.freq == other.freq).all()
         return data_all_same and time_same and freq_same
 
-
-    def noise_weighted_inner_product(self, other:"Wavelet", psd:"Wavelet") -> float:
+    def noise_weighted_inner_product(
+        self, other: "Wavelet", psd: "Wavelet"
+    ) -> float:
         """
         Compute the noise-weighted inner product of two wavelet grids given a PSD.
 
@@ -326,11 +389,11 @@ class Wavelet:
         float
             The noise-weighted inner product.
         """
-        from ...utils import noise_weighted_inner_product
-        return noise_weighted_inner_product(self, other, psd)
+        from ..utils import noise_weighted_inner_product
 
+        return noise_weighted_inner_product(self, other, psd)
 
-    def matched_filter_snr(self, template:"Wavelet", psd:"Wavelet") -> float:
+    def matched_filter_snr(self, template: "Wavelet", psd: "Wavelet") -> float:
         """
         Compute the matched filter SNR of the wavelet grid given a template.
 
@@ -347,7 +410,7 @@ class Wavelet:
         mf = self.noise_weighted_inner_product(template, psd)
         return mf / self.optimal_snr(psd)
 
-    def optimal_snr(self, psd:"Wavelet") -> float:
+    def optimal_snr(self, psd: "Wavelet") -> float:
         """
         Compute the optimal SNR of the wavelet grid given a PSD.
 
@@ -365,10 +428,27 @@ class Wavelet:
 
     def __copy__(self):
         return Wavelet(
-            data=self.data.copy(),
-            time=self.time.copy(),
-            freq=self.freq.copy()
+            data=self.data.copy(), time=self.time.copy(), freq=self.freq.copy()
         )
 
     def copy(self):
-        return self.__copy__()
+        return self.__copy__()
+
+
+class WaveletMask(Wavelet):
+    @property
+    def mask(self):
+        return self.data
+
+    def __repr__(self):
+        return f"WaveletMask({self.mask.shape}, {fmt_timerange(self.time)}, {self.freq})"
+
+    @classmethod
+    def from_frange(
+        cls, time_grid: xp.ndarray, freq_grid: xp.ndarray, frange: List[float]
+    ):
+        self = cls.zeros_from_grid(time_grid, freq_grid)
+        self.mask[
+            (freq_grid >= frange[0]) & (freq_grid <= frange[1]), :
+        ] = True
+        return self

pywavelet/{transforms/forward → types}/wavelet_bins.py

@@ -2,7 +2,8 @@ from typing import Tuple, Union
 
 import numpy as np
 
-from ..types import FrequencySeries, TimeSeries
+from .frequencyseries import FrequencySeries
+from .timeseries import TimeSeries
 
 
 def _preprocess_bins(
@@ -10,7 +11,6 @@ def _preprocess_bins(
 ) -> Tuple[int, int]:
     """preprocess the bins"""
 
-
     if isinstance(data, TimeSeries):
         N = len(data)
     elif isinstance(data, FrequencySeries):
@@ -34,7 +34,6 @@ def _get_bins(
     Nf: Union[int, None] = None,
     Nt: Union[int, None] = None,
 ) -> Tuple[np.ndarray, np.ndarray]:
-
     T = data.duration
     t_bins, f_bins = compute_bins(Nf, Nt, T)
 
@@ -42,12 +41,12 @@ def _get_bins(
     # fs = N / T
     # assert delta_f == fmax / Nf, f"delta_f={delta_f} != fmax/Nf={fmax/Nf}"
 
-    t_bins+= data.t0
+    t_bins += data.t0
 
     return t_bins, f_bins
 
 
-def compute_bins(Nf:int, Nt:int, T:float) -> Tuple[np.ndarray, np.ndarray]:
+def compute_bins(Nf: int, Nt: int, T: float) -> Tuple[np.ndarray, np.ndarray]:
     """Get the bins for the wavelet transform
     Eq 4-6 in Wavelets paper
     """
@@ -55,4 +54,4 @@ def compute_bins(Nf:int, Nt:int, T:float) -> Tuple[np.ndarray, np.ndarray]:
     delta_F = 1 / (2 * delta_T)
     t_bins = np.arange(0, Nt) * delta_T
     f_bins = np.arange(0, Nf) * delta_F
-    return  t_bins, f_bins
+    return t_bins, f_bins

pywavelet/utils.py

@@ -3,7 +3,7 @@ from typing import Union
 import numpy as np
 from scipy.interpolate import interp1d
 
-from .transforms.types import FrequencySeries, TimeSeries, Wavelet
+from .types import FrequencySeries, TimeSeries, Wavelet, WaveletMask
 
 DATA_TYPE = Union[TimeSeries, FrequencySeries, Wavelet]
 
@@ -34,10 +34,13 @@ def evolutionary_psd_from_stationary_psd(
     return Wavelet(psd_grid.T, time=t_grid, freq=f_grid)
 
 
-def noise_weighted_inner_product(d: Wavelet, h: Wavelet, PSD: Wavelet) -> float:
+def noise_weighted_inner_product(
+    d: Wavelet, h: Wavelet, PSD: Wavelet
+) -> float:
     return np.nansum((d.data * h.data) / PSD.data)
 
-def compute_snr(d:Wavelet, h: Wavelet, PSD: Wavelet) -> float:
+
+def compute_snr(d: Wavelet, h: Wavelet, PSD: Wavelet) -> float:
     """Compute the SNR of a model h[ti,fi] given freqseries d[ti,fi] and PSD[ti,fi].
 
     SNR(h) = Sum_{ti,fi} [ h_hat[ti,fi] d[ti,fi] / PSD[ti,fi]
@@ -60,5 +63,14 @@ def compute_snr(d:Wavelet, h: Wavelet, PSD: Wavelet) -> float:
     return np.sqrt(noise_weighted_inner_product(d, h, PSD))
 
 
-def compute_likelihood(data:Wavelet, template:Wavelet, psd:Wavelet) -> float:
-    return -0.5 * np.nansum((data.data - template.data) ** 2 / psd.data)
+def compute_likelihood(
+    data: Wavelet, template: Wavelet, psd: Wavelet, mask: WaveletMask = None
+) -> float:
+    d = data.data
+    h = template.data
+    p = psd.data
+    if mask is not None:
+        m = mask.mask
+        d, h, p = d * m, h * m, p * m
+
+    return -0.5 * np.nansum((d - h) ** 2 / p)

{pywavelet-0.0.5.dist-info → pywavelet-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pywavelet
-Version: 0.0.5
+Version: 0.1.1
 Summary: WDM wavelet transform your time/freq series!
 Author-email: Pywavelet Team <avi.vajpeyi@gmail.com>
 Project-URL: Homepage, https://pywavelet.github.io/pywavelet/

pywavelet-0.1.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+pywavelet/__init__.py,sha256=zcK3Qj4wTrGZF1rU3aT6yA9LvliAOD4DVOY7gNfHhCI,53
+pywavelet/_version.py,sha256=PKIMyjdUACH4-ONvtunQCnYE2UhlMfp9su83e3HXl5E,411
+pywavelet/logger.py,sha256=DyKC-pJ_N9GlVeXL00E1D8hUd8GceBg-pnn7g1YPKcM,391
+pywavelet/utils.py,sha256=l47C643nGlV9q4a0G7wtKzuas0Ou4En2e1FTATCgwlw,1907
+pywavelet/transforms/__init__.py,sha256=1Ibsup9UwMajeZ9NCQ4BN15qZTeJ_EHkgGu8XNFdA18,255
+pywavelet/transforms/phi_computer.py,sha256=vo1PK9Z70kKV-1lfyRoxWdhSYqwIgJK5CRCCJVei3xI,4545
+pywavelet/transforms/forward/__init__.py,sha256=E_A8plyfTSKDRXlAAvdiRMTe9f3Y6MbK3pXMHFg8mr0,121
+pywavelet/transforms/forward/from_freq.py,sha256=wCiyLpzJE3rGxYjQBdXlwkxPIRYhQWjKq0C_8zYlmDk,2697
+pywavelet/transforms/forward/from_time.py,sha256=-Y6VEKwDCYBAHAjLdO46vT-6alpM5fXTgTZ_xkYxqA8,2381
+pywavelet/transforms/forward/main.py,sha256=Gfy0sp-woy_3ihKMzuk2WuZ7dRk-Mm6sp5dVpYrSvj4,4005
+pywavelet/transforms/inverse/__init__.py,sha256=J4KIzPzbHNg_8fV_c1MpPq3slSqHQV0j3VFrjfd1Nog,121
+pywavelet/transforms/inverse/main.py,sha256=Q7wUaRjB1sgqdB7dniWQGbPTWYQNnIsIrYtjsaHJEdE,3012
+pywavelet/transforms/inverse/to_freq.py,sha256=so_TDbwdS1N8sd1QcpeAEkI10XFDtoFJGohtD4YulZM,2809
+pywavelet/transforms/inverse/to_time.py,sha256=w5vmImdsb_4YeInZtXh0llsThLTxS0tmYDlNGJ-IUew,5080
+pywavelet/types/__init__.py,sha256=5YptzQvYBnRfC8N5lpOBf9I1lzpJ0pw0QMnvIcwP3YI,122
+pywavelet/types/common.py,sha256=OSAW6GqLTgqJ-RYEv__XbzsfFd8AFo5w-ctXQ4XAFZo,1317
+pywavelet/types/frequencyseries.py,sha256=UqcE6UQfw5HZm4na2q9k-X-mfqO-BCiTAvGjaYpSrwc,7518
+pywavelet/types/plotting.py,sha256=JNDxeP-fB8U09E90J-rVT-h5yCGA_tGRHtctbgINiRo,10625
+pywavelet/types/timeseries.py,sha256=6DPO0xLi4Dq2srhJLmavFMf4fYIC3wwdbyMU7lMdjTo,9446
+pywavelet/types/wavelet.py,sha256=ptTEnq6nRZiW2x6g_NV_FuoeVNOsbNOu6caSxYDZNgk,12583
+pywavelet/types/wavelet_bins.py,sha256=SC9nhyigWvOfs2TbH8-Ck_iS1Mrz6sG-8EaIFYLIHuk,1453
+pywavelet-0.1.1.dist-info/METADATA,sha256=OgKTqqZQKfhCCcsYpcXnrut-2EAH42c3tCpCGc0PIDg,1307
+pywavelet-0.1.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+pywavelet-0.1.1.dist-info/top_level.txt,sha256=g0Ezt0Rg0X-nrd-a0pAXKVRkuWNsF2M9Ynsjb9b2UYQ,10
+pywavelet-0.1.1.dist-info/RECORD,,

pywavelet-0.0.5.dist-info/RECORD

@@ -1,25 +0,0 @@
-pywavelet/__init__.py,sha256=zcK3Qj4wTrGZF1rU3aT6yA9LvliAOD4DVOY7gNfHhCI,53
-pywavelet/_version.py,sha256=EJB7__SNK9kQS_SWZB_U4DHJ3P8ftF6etZEihTYnuXE,411
-pywavelet/logger.py,sha256=u5Et6QLUU0IuTnPnxfev5-4GYmihTo7_yBCTf-rVUsA,377
-pywavelet/utils.py,sha256=rbmZ-PrnFstq05kh6xj8emuQ3-7oXqZinU03bpg3N7A,1746
-pywavelet/transforms/__init__.py,sha256=FolK8WiVEJmGDC9xMupYVI_essXaXS4LYWKbqEqGx6o,289
-pywavelet/transforms/phi_computer.py,sha256=vo1PK9Z70kKV-1lfyRoxWdhSYqwIgJK5CRCCJVei3xI,4545
-pywavelet/transforms/forward/__init__.py,sha256=Yq4Tg3Ze98-17C9FIkOqMUdiLHe9x_YoyuRvxOxMOP0,176
-pywavelet/transforms/forward/from_freq.py,sha256=HWADciv746P5zWNhnyRKDEDACTQnwDTR4usf2k0VIWk,2663
-pywavelet/transforms/forward/from_time.py,sha256=zfpvmq7UHnynzAnsM_Pf4MXpO1GJ0TaCCERQKNsaBNU,2340
-pywavelet/transforms/forward/main.py,sha256=FJSLUUsk3I91lUeB2YFiXQdX8gB9maFW60e4tgrd45A,4053
-pywavelet/transforms/forward/wavelet_bins.py,sha256=43CHVSjNgC59Af1_h9t33VBBqGHJmIUaOUhJgekhMnc,1419
-pywavelet/transforms/inverse/__init__.py,sha256=J4KIzPzbHNg_8fV_c1MpPq3slSqHQV0j3VFrjfd1Nog,121
-pywavelet/transforms/inverse/main.py,sha256=l5yFvzmWObrO5Xt_8KYp62w829ab0pQLxcv0-QxkvG0,3015
-pywavelet/transforms/inverse/to_freq.py,sha256=SExZMax-8A-tJpIA86pYY61X2qvlZ2MrZY27uzCQSV0,2778
-pywavelet/transforms/inverse/to_time.py,sha256=BAYvrr41QHIbzwYMPyMnzv5mqSx40YigmBruWBwtZwc,5041
-pywavelet/transforms/types/__init__.py,sha256=4wUTVBk6A02xjZUY_w056eUZurYI9vVfa--I3Q6Udng,109
-pywavelet/transforms/types/common.py,sha256=sLBn2d9cuL6NYeIv6NIogDjY6rYPZAPzCtWGwMlAwkI,1290
-pywavelet/transforms/types/frequencyseries.py,sha256=Rtwt486UL0-TgMAdcMMVpyfi5PSLzxFcdE_RsYuyxQk,7463
-pywavelet/transforms/types/plotting.py,sha256=aEIFoSuQRYwYc2639yLkbujXx_aav5A5tXG29rOSMOQ,10275
-pywavelet/transforms/types/timeseries.py,sha256=Nl1tiKZ7kwu-EZ5JtubwgzgyjQZR86eGU3C3kElIPNg,9296
-pywavelet/transforms/types/wavelet.py,sha256=raODhyegBd1_esuv2YP6tK_Nj9fYaLQ6O4pxpiFAVZU,10790
-pywavelet-0.0.5.dist-info/METADATA,sha256=BaLK8jbUqss_8BeGWOlf_031PoCAlEV4rmuSaitQd0E,1307
-pywavelet-0.0.5.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-pywavelet-0.0.5.dist-info/top_level.txt,sha256=g0Ezt0Rg0X-nrd-a0pAXKVRkuWNsF2M9Ynsjb9b2UYQ,10
-pywavelet-0.0.5.dist-info/RECORD,,