eegdash 0.3.3.dev61__py3-none-any.whl → 0.5.0.dev180784713__py3-none-any.whl

eegdash/features/feature_bank/complexity.py

@@ -3,11 +3,10 @@ import numpy as np
 from sklearn.neighbors import KDTree
 
 from ..decorators import FeaturePredecessor, univariate_feature
-from ..extractors import FeatureExtractor
 from .signal import SIGNAL_PREDECESSORS
 
 __all__ = [
-    "EntropyFeatureExtractor",
+    "complexity_entropy_preprocessor",
     "complexity_approx_entropy",
     "complexity_sample_entropy",
     "complexity_svd_entropy",
@@ -30,28 +29,31 @@ def _channel_app_samp_entropy_counts(x, m, r, l):
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
-class EntropyFeatureExtractor(FeatureExtractor):
-    def preprocess(self, x, m=2, r=0.2, l=1):
-        rr = r * x.std(axis=-1)
-        counts_m = np.empty((*x.shape[:-1], (x.shape[-1] - m + 1) // l))
-        counts_mp1 = np.empty((*x.shape[:-1], (x.shape[-1] - m) // l))
-        for i in np.ndindex(x.shape[:-1]):
-            counts_m[*i, :] = _channel_app_samp_entropy_counts(x[i], m, rr[i], l)
-            counts_mp1[*i, :] = _channel_app_samp_entropy_counts(x[i], m + 1, rr[i], l)
-        return counts_m, counts_mp1
-
-
-@FeaturePredecessor(EntropyFeatureExtractor)
+def complexity_entropy_preprocessor(x, /, m=2, r=0.2, l=1):
+    rr = r * x.std(axis=-1)
+    counts_m = np.empty((*x.shape[:-1], (x.shape[-1] - m + 1) // l))
+    counts_mp1 = np.empty((*x.shape[:-1], (x.shape[-1] - m) // l))
+    for i in np.ndindex(x.shape[:-1]):
+        counts_m[i + (slice(None),)] = _channel_app_samp_entropy_counts(
+            x[i], m, rr[i], l
+        )
+        counts_mp1[i + (slice(None),)] = _channel_app_samp_entropy_counts(
+            x[i], m + 1, rr[i], l
+        )
+    return counts_m, counts_mp1
+
+
+@FeaturePredecessor(complexity_entropy_preprocessor)
 @univariate_feature
-def complexity_approx_entropy(counts_m, counts_mp1):
+def complexity_approx_entropy(counts_m, counts_mp1, /):
     phi_m = np.log(counts_m / counts_m.shape[-1]).mean(axis=-1)
     phi_mp1 = np.log(counts_mp1 / counts_mp1.shape[-1]).mean(axis=-1)
     return phi_m - phi_mp1
 
 
-@FeaturePredecessor(EntropyFeatureExtractor)
+@FeaturePredecessor(complexity_entropy_preprocessor)
 @univariate_feature
-def complexity_sample_entropy(counts_m, counts_mp1):
+def complexity_sample_entropy(counts_m, counts_mp1, /):
     A = np.sum(counts_mp1 - 1, axis=-1)
     B = np.sum(counts_m - 1, axis=-1)
     return -np.log(A / B)
@@ -59,10 +61,10 @@ def complexity_sample_entropy(counts_m, counts_mp1):
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def complexity_svd_entropy(x, m=10, tau=1):
+def complexity_svd_entropy(x, /, m=10, tau=1):
     x_emb = np.empty((*x.shape[:-1], (x.shape[-1] - m + 1) // tau, m))
     for i in np.ndindex(x.shape[:-1]):
-        x_emb[*i, :, :] = _create_embedding(x[i], m, tau)
+        x_emb[i + (slice(None), slice(None))] = _create_embedding(x[i], m, tau)
     s = np.linalg.svdvals(x_emb)
     s /= s.sum(axis=-1, keepdims=True)
     return -np.sum(s * np.log(s), axis=-1)
@@ -71,7 +73,7 @@ def complexity_svd_entropy(x, m=10, tau=1):
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
 @nb.njit(cache=True, fastmath=True)
-def complexity_lempel_ziv(x, threshold=None, normalize=True):
+def complexity_lempel_ziv(x, /, threshold=None, normalize=True):
     lzc = np.empty(x.shape[:-1])
     for i in np.ndindex(x.shape[:-1]):
         t = np.median(x[i]) if threshold is None else threshold

eegdash/features/feature_bank/connectivity.py

@@ -4,56 +4,55 @@ import numpy as np
 from scipy.signal import csd
 
 from ..decorators import FeaturePredecessor, bivariate_feature
-from ..extractors import BivariateFeature, FeatureExtractor
+from ..extractors import BivariateFeature
 from . import utils
+from .signal import SIGNAL_PREDECESSORS
 
 __all__ = [
-    "CoherenceFeatureExtractor",
+    "connectivity_coherency_preprocessor",
     "connectivity_magnitude_square_coherence",
     "connectivity_imaginary_coherence",
     "connectivity_lagged_coherence",
 ]
 
 
-class CoherenceFeatureExtractor(FeatureExtractor):
-    def preprocess(self, x, **kwargs):
-        f_min = kwargs.pop("f_min") if "f_min" in kwargs else None
-        f_max = kwargs.pop("f_max") if "f_max" in kwargs else None
-        assert "fs" in kwargs and "nperseg" in kwargs
-        kwargs["axis"] = -1
-        n = x.shape[1]
-        idx_x, idx_y = BivariateFeature.get_pair_iterators(n)
-        ix, iy = list(chain(range(n), idx_x)), list(chain(range(n), idx_y))
-        f, s = csd(x[:, ix], x[:, iy], **kwargs)
-        f_min, f_max = utils.get_valid_freq_band(
-            kwargs["fs"], x.shape[-1], f_min, f_max
-        )
-        f, s = utils.slice_freq_band(f, s, f_min=f_min, f_max=f_max)
-        p, sxy = np.split(s, [n], axis=1)
-        sxx, syy = p[:, idx_x].real, p[:, idx_y].real
-        c = sxy / np.sqrt(sxx * syy)
-        return f, c
-
-
-@FeaturePredecessor(CoherenceFeatureExtractor)
+@FeaturePredecessor(*SIGNAL_PREDECESSORS)
+def connectivity_coherency_preprocessor(x, /, **kwargs):
+    f_min = kwargs.pop("f_min") if "f_min" in kwargs else None
+    f_max = kwargs.pop("f_max") if "f_max" in kwargs else None
+    assert "fs" in kwargs and "nperseg" in kwargs
+    kwargs["axis"] = -1
+    n = x.shape[1]
+    idx_x, idx_y = BivariateFeature.get_pair_iterators(n)
+    ix, iy = list(chain(range(n), idx_x)), list(chain(range(n), idx_y))
+    f, s = csd(x[:, ix], x[:, iy], **kwargs)
+    f_min, f_max = utils.get_valid_freq_band(kwargs["fs"], x.shape[-1], f_min, f_max)
+    f, s = utils.slice_freq_band(f, s, f_min=f_min, f_max=f_max)
+    p, sxy = np.split(s, [n], axis=1)
+    sxx, syy = p[:, idx_x].real, p[:, idx_y].real
+    c = sxy / np.sqrt(sxx * syy)
+    return f, c
+
+
+@FeaturePredecessor(connectivity_coherency_preprocessor)
 @bivariate_feature
-def connectivity_magnitude_square_coherence(f, c, bands=utils.DEFAULT_FREQ_BANDS):
+def connectivity_magnitude_square_coherence(f, c, /, bands=utils.DEFAULT_FREQ_BANDS):
     # https://neuroimage.usc.edu/brainstorm/Tutorials/Connectivity
     coher = c.real**2 + c.imag**2
     return utils.reduce_freq_bands(f, coher, bands, np.mean)
 
 
-@FeaturePredecessor(CoherenceFeatureExtractor)
+@FeaturePredecessor(connectivity_coherency_preprocessor)
 @bivariate_feature
-def connectivity_imaginary_coherence(f, c, bands=utils.DEFAULT_FREQ_BANDS):
+def connectivity_imaginary_coherence(f, c, /, bands=utils.DEFAULT_FREQ_BANDS):
     # https://neuroimage.usc.edu/brainstorm/Tutorials/Connectivity
     coher = c.imag
     return utils.reduce_freq_bands(f, coher, bands, np.mean)
 
 
-@FeaturePredecessor(CoherenceFeatureExtractor)
+@FeaturePredecessor(connectivity_coherency_preprocessor)
 @bivariate_feature
-def connectivity_lagged_coherence(f, c, bands=utils.DEFAULT_FREQ_BANDS):
+def connectivity_lagged_coherence(f, c, /, bands=utils.DEFAULT_FREQ_BANDS):
     # https://neuroimage.usc.edu/brainstorm/Tutorials/Connectivity
     coher = c.imag / np.sqrt(1 - c.real)
     return utils.reduce_freq_bands(f, coher, bands, np.mean)

eegdash/features/feature_bank/csp.py

@@ -3,8 +3,9 @@ import numpy as np
 import scipy
 import scipy.linalg
 
-from ..decorators import multivariate_feature
+from ..decorators import FeaturePredecessor, multivariate_feature
 from ..extractors import TrainableFeature
+from .signal import SIGNAL_PREDECESSORS
 
 __all__ = [
     "CommonSpatialPattern",
@@ -21,6 +22,7 @@ def _update_mean_cov(count, mean, cov, x_count, x_mean, x_cov):
     cov[:] -= np.outer(mean, mean)
 
 
+@FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @multivariate_feature
 class CommonSpatialPattern(TrainableFeature):
     def __init__(self):

eegdash/features/feature_bank/dimensionality.py

@@ -17,7 +17,7 @@ __all__ = [
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
 @nb.njit(cache=True, fastmath=True)
-def dimensionality_higuchi_fractal_dim(x, k_max=10, eps=1e-7):
+def dimensionality_higuchi_fractal_dim(x, /, k_max=10, eps=1e-7):
     N = x.shape[-1]
     hfd = np.empty(x.shape[:-1])
     log_k = np.vstack((-np.log(np.arange(1, k_max + 1)), np.ones(k_max))).T
@@ -26,7 +26,7 @@ def dimensionality_higuchi_fractal_dim(x, k_max=10, eps=1e-7):
     for i in np.ndindex(x.shape[:-1]):
         for k in range(1, k_max + 1):
             for m in range(k):
-                L_km[m] = np.mean(np.abs(np.diff(x[*i, m:], n=k)))
+                L_km[m] = np.mean(np.abs(np.diff(x[i + (slice(m, None),)], n=k)))
             L_k[k - 1] = (N - 1) * np.sum(L_km[:k]) / (k**3)
         L_k = np.maximum(L_k, eps)
         hfd[i] = np.linalg.lstsq(log_k, np.log(L_k))[0][0]
@@ -35,7 +35,7 @@ def dimensionality_higuchi_fractal_dim(x, k_max=10, eps=1e-7):
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def dimensionality_petrosian_fractal_dim(x):
+def dimensionality_petrosian_fractal_dim(x, /):
     nd = signal_zero_crossings(np.diff(x, axis=-1))
     log_n = np.log(x.shape[-1])
     return log_n / (np.log(nd) + log_n)
@@ -43,7 +43,7 @@ def dimensionality_petrosian_fractal_dim(x):
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def dimensionality_katz_fractal_dim(x):
+def dimensionality_katz_fractal_dim(x, /):
     dists = np.abs(np.diff(x, axis=-1))
     L = dists.sum(axis=-1)
     a = dists.mean(axis=-1)
@@ -79,7 +79,7 @@ def _hurst_exp(x, ns, a, gamma_ratios, log_n):
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def dimensionality_hurst_exp(x):
+def dimensionality_hurst_exp(x, /):
     ns = np.unique(np.power(2, np.arange(2, np.log2(x.shape[-1]) - 1)).astype(int))
     idx = ns > 340
     gamma_ratios = np.empty(ns.shape[0])
@@ -94,7 +94,7 @@ def dimensionality_hurst_exp(x):
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
 @nb.njit(cache=True, fastmath=True)
-def dimensionality_detrended_fluctuation_analysis(x):
+def dimensionality_detrended_fluctuation_analysis(x, /):
     ns = np.unique(np.floor(np.power(2, np.arange(2, np.log2(x.shape[-1]) - 1))))
     a = np.vstack((np.arange(ns[-1]), np.ones(int(ns[-1])))).T
     log_n = np.vstack((np.log(ns), np.ones(ns.shape[0]))).T

eegdash/features/feature_bank/signal.py

@@ -4,93 +4,92 @@ import numpy as np
 from scipy import signal, stats
 
 from ..decorators import FeaturePredecessor, univariate_feature
-from ..extractors import FeatureExtractor
 
 __all__ = [
-    "HilbertFeatureExtractor",
-    "signal_mean",
-    "signal_variance",
-    "signal_skewness",
+    "signal_hilbert_preprocessor",
+    "SIGNAL_PREDECESSORS",
+    "signal_decorrelation_time",
+    "signal_hjorth_activity",
+    "signal_hjorth_complexity",
+    "signal_hjorth_mobility",
     "signal_kurtosis",
-    "signal_std",
-    "signal_root_mean_square",
+    "signal_line_length",
+    "signal_mean",
     "signal_peak_to_peak",
     "signal_quantile",
+    "signal_root_mean_square",
+    "signal_skewness",
+    "signal_std",
+    "signal_variance",
     "signal_zero_crossings",
-    "signal_line_length",
-    "signal_hjorth_activity",
-    "signal_hjorth_mobility",
-    "signal_hjorth_complexity",
-    "signal_decorrelation_time",
 ]
 
 
-@FeaturePredecessor(FeatureExtractor)
-class HilbertFeatureExtractor(FeatureExtractor):
-    def preprocess(self, x):
-        return np.abs(signal.hilbert(x - x.mean(axis=-1, keepdims=True), axis=-1))
+@FeaturePredecessor()
+def signal_hilbert_preprocessor(x, /):
+    return np.abs(signal.hilbert(x - x.mean(axis=-1, keepdims=True), axis=-1))
 
 
-SIGNAL_PREDECESSORS = [FeatureExtractor, HilbertFeatureExtractor]
+SIGNAL_PREDECESSORS = [None, signal_hilbert_preprocessor]
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_mean(x):
+def signal_mean(x, /):
     return x.mean(axis=-1)
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_variance(x, **kwargs):
+def signal_variance(x, /, **kwargs):
     return x.var(axis=-1, **kwargs)
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_std(x, **kwargs):
+def signal_std(x, /, **kwargs):
     return x.std(axis=-1, **kwargs)
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_skewness(x, **kwargs):
+def signal_skewness(x, /, **kwargs):
     return stats.skew(x, axis=x.ndim - 1, **kwargs)
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_kurtosis(x, **kwargs):
+def signal_kurtosis(x, /, **kwargs):
     return stats.kurtosis(x, axis=x.ndim - 1, **kwargs)
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_root_mean_square(x):
+def signal_root_mean_square(x, /):
     return np.sqrt(np.power(x, 2).mean(axis=-1))
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_peak_to_peak(x, **kwargs):
+def signal_peak_to_peak(x, /, **kwargs):
     return np.ptp(x, axis=-1, **kwargs)
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_quantile(x, q: numbers.Number = 0.5, **kwargs):
+def signal_quantile(x, /, q: numbers.Number = 0.5, **kwargs):
     return np.quantile(x, q=q, axis=-1, **kwargs)
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_line_length(x):
+def signal_line_length(x, /):
     return np.abs(np.diff(x, axis=-1)).mean(axis=-1)
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_zero_crossings(x, threshold=1e-15):
+def signal_zero_crossings(x, /, threshold=1e-15):
     zero_ind = np.logical_and(x > -threshold, x < threshold)
     zero_cross = np.diff(zero_ind, axis=-1).astype(int).sum(axis=-1)
     y = x.copy()
@@ -101,13 +100,13 @@ def signal_zero_crossings(x, threshold=1e-15):
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_hjorth_mobility(x):
+def signal_hjorth_mobility(x, /):
     return np.diff(x, axis=-1).std(axis=-1) / x.std(axis=-1)
 
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_hjorth_complexity(x):
+def signal_hjorth_complexity(x, /):
     return (np.diff(x, 2, axis=-1).std(axis=-1) * x.std(axis=-1)) / np.diff(
         x, axis=-1
     ).var(axis=-1)
@@ -115,7 +114,7 @@ def signal_hjorth_complexity(x):
 
 @FeaturePredecessor(*SIGNAL_PREDECESSORS)
 @univariate_feature
-def signal_decorrelation_time(x, fs=1):
+def signal_decorrelation_time(x, /, fs=1):
     f = np.fft.fft(x - x.mean(axis=-1, keepdims=True), axis=-1)
     ac = np.fft.ifft(f.real**2 + f.imag**2, axis=-1)[..., : x.shape[-1] // 2]
     dct = np.empty(x.shape[:-1])

eegdash/features/feature_bank/spectral.py

@@ -3,13 +3,13 @@ import numpy as np
 from scipy.signal import welch
 
 from ..decorators import FeaturePredecessor, univariate_feature
-from ..extractors import FeatureExtractor
 from . import utils
+from .signal import SIGNAL_PREDECESSORS
 
 __all__ = [
-    "SpectralFeatureExtractor",
-    "NormalizedSpectralFeatureExtractor",
-    "DBSpectralFeatureExtractor",
+    "spectral_preprocessor",
+    "spectral_normalized_preprocessor",
+    "spectral_db_preprocessor",
     "spectral_root_total_power",
     "spectral_moment",
     "spectral_entropy",
@@ -22,84 +22,80 @@ __all__ = [
 ]
 
 
-class SpectralFeatureExtractor(FeatureExtractor):
-    def preprocess(self, x, **kwargs):
-        f_min = kwargs.pop("f_min") if "f_min" in kwargs else None
-        f_max = kwargs.pop("f_max") if "f_max" in kwargs else None
-        assert "fs" in kwargs
-        kwargs["axis"] = -1
-        f, p = welch(x, **kwargs)
-        f_min, f_max = utils.get_valid_freq_band(
-            kwargs["fs"], x.shape[-1], f_min, f_max
-        )
-        f, p = utils.slice_freq_band(f, p, f_min=f_min, f_max=f_max)
-        return f, p
+@FeaturePredecessor(*SIGNAL_PREDECESSORS)
+def spectral_preprocessor(x, /, **kwargs):
+    f_min = kwargs.pop("f_min") if "f_min" in kwargs else None
+    f_max = kwargs.pop("f_max") if "f_max" in kwargs else None
+    assert "fs" in kwargs
+    kwargs["axis"] = -1
+    f, p = welch(x, **kwargs)
+    f_min, f_max = utils.get_valid_freq_band(kwargs["fs"], x.shape[-1], f_min, f_max)
+    f, p = utils.slice_freq_band(f, p, f_min=f_min, f_max=f_max)
+    return f, p
 
 
-@FeaturePredecessor(SpectralFeatureExtractor)
-class NormalizedSpectralFeatureExtractor(FeatureExtractor):
-    def preprocess(self, *x):
-        return (*x[:-1], x[-1] / x[-1].sum(axis=-1, keepdims=True))
+@FeaturePredecessor(spectral_preprocessor)
+def spectral_normalized_preprocessor(f, p, /):
+    return f, p / p.sum(axis=-1, keepdims=True)
 
 
-@FeaturePredecessor(SpectralFeatureExtractor)
-class DBSpectralFeatureExtractor(FeatureExtractor):
-    def preprocess(self, *x, eps=1e-15):
-        return (*x[:-1], 10 * np.log10(x[-1] + eps))
+@FeaturePredecessor(spectral_preprocessor)
+def spectral_db_preprocessor(f, p, /, eps=1e-15):
+    return f, 10 * np.log10(p + eps)
 
 
-@FeaturePredecessor(SpectralFeatureExtractor)
+@FeaturePredecessor(spectral_preprocessor)
 @univariate_feature
-def spectral_root_total_power(f, p):
+def spectral_root_total_power(f, p, /):
     return np.sqrt(p.sum(axis=-1))
 
 
-@FeaturePredecessor(NormalizedSpectralFeatureExtractor)
+@FeaturePredecessor(spectral_normalized_preprocessor)
 @univariate_feature
-def spectral_moment(f, p):
+def spectral_moment(f, p, /):
     return np.sum(f * p, axis=-1)
 
 
-@FeaturePredecessor(SpectralFeatureExtractor)
+@FeaturePredecessor(spectral_preprocessor)
 @univariate_feature
-def spectral_hjorth_activity(f, p):
+def spectral_hjorth_activity(f, p, /):
     return np.sum(p, axis=-1)
 
 
-@FeaturePredecessor(NormalizedSpectralFeatureExtractor)
+@FeaturePredecessor(spectral_normalized_preprocessor)
 @univariate_feature
-def spectral_hjorth_mobility(f, p):
+def spectral_hjorth_mobility(f, p, /):
     return np.sqrt(np.sum(np.power(f, 2) * p, axis=-1))
 
 
-@FeaturePredecessor(NormalizedSpectralFeatureExtractor)
+@FeaturePredecessor(spectral_normalized_preprocessor)
 @univariate_feature
-def spectral_hjorth_complexity(f, p):
+def spectral_hjorth_complexity(f, p, /):
     return np.sqrt(np.sum(np.power(f, 4) * p, axis=-1))
 
 
-@FeaturePredecessor(NormalizedSpectralFeatureExtractor)
+@FeaturePredecessor(spectral_normalized_preprocessor)
 @univariate_feature
-def spectral_entropy(f, p):
+def spectral_entropy(f, p, /):
     idx = p > 0
     plogp = np.zeros_like(p)
     plogp[idx] = p[idx] * np.log(p[idx])
     return -np.sum(plogp, axis=-1)
 
 
-@FeaturePredecessor(NormalizedSpectralFeatureExtractor)
+@FeaturePredecessor(spectral_normalized_preprocessor)
 @univariate_feature
 @nb.njit(cache=True, fastmath=True)
-def spectral_edge(f, p, edge=0.9):
+def spectral_edge(f, p, /, edge=0.9):
     se = np.empty(p.shape[:-1])
     for i in np.ndindex(p.shape[:-1]):
         se[i] = f[np.searchsorted(np.cumsum(p[i]), edge)]
     return se
 
 
-@FeaturePredecessor(DBSpectralFeatureExtractor)
+@FeaturePredecessor(spectral_db_preprocessor)
 @univariate_feature
-def spectral_slope(f, p):
+def spectral_slope(f, p, /):
     log_f = np.vstack((np.log(f), np.ones(f.shape[0]))).T
     r = np.linalg.lstsq(log_f, p.reshape(-1, p.shape[-1]).T)[0]
     r = r.reshape(2, *p.shape[:-1])
@@ -107,10 +103,10 @@ def spectral_slope(f, p):
 
 
 @FeaturePredecessor(
-    SpectralFeatureExtractor,
-    NormalizedSpectralFeatureExtractor,
-    DBSpectralFeatureExtractor,
+    spectral_preprocessor,
+    spectral_normalized_preprocessor,
+    spectral_db_preprocessor,
 )
 @univariate_feature
-def spectral_bands_power(f, p, bands=utils.DEFAULT_FREQ_BANDS):
+def spectral_bands_power(f, p, /, bands=utils.DEFAULT_FREQ_BANDS):
     return utils.reduce_freq_bands(f, p, bands, np.sum)

eegdash/features/feature_bank/utils.py

@@ -1,5 +1,13 @@
 import numpy as np
 
+__all__ = [
+    "DEFAULT_FREQ_BANDS",
+    "get_valid_freq_band",
+    "reduce_freq_bands",
+    "slice_freq_band",
+]
+
+
 DEFAULT_FREQ_BANDS = {
     "delta": (1, 4.5),
     "theta": (4.5, 8),