linting changes

pynapple/process/__init__.py

@@ -15,6 +15,7 @@
     shift_timestamps,
     shuffle_ts_intervals,
 )
+from .signal_processing import *
 from .tuning_curves import (
     compute_1d_mutual_info,
     compute_1d_tuning_curves,
@@ -24,4 +25,3 @@
     compute_2d_tuning_curves_continuous,
     compute_discrete_tuning_curves,
 )
-from .signal_processing import *

pynapple/process/signal_processing.py

@@ -3,12 +3,15 @@
 
 """
 
-import numpy as np
 from itertools import repeat
+
+import numpy as np
+
 import pynapple as nap
 
+
 def compute_fft(sig, fs):
-    """  
+    """
     Performs numpy fft on sig, returns output
     ..todo: Make sig handle TsdFrame, TsdTensor
 
@@ -40,7 +43,7 @@ def morlet(M, ncycles=5.0, scaling=1.0):
         Morelet wavelet kernel
     """
     x = np.linspace(-scaling * 2 * np.pi, scaling * 2 * np.pi, M)
-    return np.exp(1j * ncycles * x) * (np.exp(-0.5 * (x ** 2)) * np.pi ** (-0.25))
+    return np.exp(1j * ncycles * x) * (np.exp(-0.5 * (x**2)) * np.pi ** (-0.25))
 
 
 """  
@@ -70,14 +73,16 @@ def _check_n_cycles(n_cycles, len_cycles=None):
     """
     if isinstance(n_cycles, (int, float, np.number)):
         if n_cycles <= 0:
-            raise ValueError('Number of cycles must be a positive number.')
+            raise ValueError("Number of cycles must be a positive number.")
         n_cycles = repeat(n_cycles)
     elif isinstance(n_cycles, (tuple, list, np.ndarray)):
         for cycle in n_cycles:
             if cycle <= 0:
-                raise ValueError('Each number of cycles must be a positive number.')
+                raise ValueError("Each number of cycles must be a positive number.")
         if len_cycles and len(n_cycles) != len_cycles:
-            raise ValueError('The length of number of cycles does not match other inputs.')
+            raise ValueError(
+                "The length of number of cycles does not match other inputs."
+            )
         n_cycles = iter(n_cycles)
     return n_cycles
 
@@ -105,7 +110,7 @@ def _create_freqs(freq_start, freq_stop, freq_step=1):
     return np.arange(freq_start, freq_stop + freq_step, freq_step)
 
 
-def compute_wavelet_transform(sig, fs, freqs, n_cycles=7, scaling=0.5, norm='amp'):
+def compute_wavelet_transform(sig, fs, freqs, n_cycles=7, scaling=0.5, norm="amp"):
     """
     Compute the time-frequency representation of a signal using morlet wavelets.
 
@@ -152,14 +157,20 @@ def compute_wavelet_transform(sig, fs, freqs, n_cycles=7, scaling=0.5, norm='amp
             mwt[ind, :] = _convolve_wavelet(sig, fs, freq, n_cycle, scaling, norm=norm)
         return nap.TsdFrame(t=sig.index, d=np.transpose(mwt))
     else:
-        mwt = np.zeros([sig.values.shape[0], len(freqs), sig.values.shape[1]], dtype=complex)
+        mwt = np.zeros(
+            [sig.values.shape[0], len(freqs), sig.values.shape[1]], dtype=complex
+        )
         for channel_i in range(sig.values.shape[1]):
             for ind, (freq, n_cycle) in enumerate(zip(freqs, n_cycles)):
-                mwt[:, ind, channel_i] = _convolve_wavelet(sig[:, channel_i], fs, freq, n_cycle, scaling, norm=norm)
+                mwt[:, ind, channel_i] = _convolve_wavelet(
+                    sig[:, channel_i], fs, freq, n_cycle, scaling, norm=norm
+                )
         return nap.TsdTensor(t=sig.index, d=mwt)
 
 
-def _convolve_wavelet(sig, fs, freq, n_cycles=7, scaling=0.5, wavelet_len=None, norm='sss'):
+def _convolve_wavelet(
+    sig, fs, freq, n_cycles=7, scaling=0.5, wavelet_len=None, norm="sss"
+):
     """
     Convolve a signal with a complex wavelet.
 
@@ -195,16 +206,18 @@ def _convolve_wavelet(sig, fs, freq, n_cycles=7, scaling=0.5, wavelet_len=None,
     * Taking np.abs() of output gives the analytic amplitude.
     * Taking np.angle() of output gives the analytic phase. ..todo: this this still true?
     """
-    if norm not in ['sss', 'amp']:
-        raise ValueError('Given `norm` must be `sss` or `amp`')
+    if norm not in ["sss", "amp"]:
+        raise ValueError("Given `norm` must be `sss` or `amp`")
     if wavelet_len is None:
         wavelet_len = int(n_cycles * fs / freq)
     if wavelet_len > sig.shape[-1]:
-        raise ValueError('The length of the wavelet is greater than the signal. Can not proceed.')
+        raise ValueError(
+            "The length of the wavelet is greater than the signal. Can not proceed."
+        )
     morlet_f = morlet(wavelet_len, ncycles=n_cycles, scaling=scaling)
-    if norm == 'sss':
+    if norm == "sss":
         morlet_f = morlet_f / np.sqrt(np.sum(np.abs(morlet_f) ** 2))
-    elif norm == 'amp':
+    elif norm == "amp":
         morlet_f = morlet_f / np.sum(np.abs(morlet_f))
     mwt_real = sig.convolve(np.real(morlet_f))
     mwt_imag = sig.convolve(np.imag(morlet_f))