Big clean in components and reoraginze in folder (#4140)

Author: samuelgarcia

doc/how_to/analyze_neuropixels.rst

@@ -442,7 +442,7 @@ Let’s use here the ``locally_exclusive`` method for detection and the
 
     from spikeinterface.sortingcomponents.peak_localization import localize_peaks
 
-    peak_locations = localize_peaks(rec, peaks, method='center_of_mass', radius_um=50., **job_kwargs)
+    peak_locations = localize_peaks(rec, peaks, method='center_of_mass', method_kwargs=dict(radius_um=50.), **job_kwargs)
 
 
 

doc/modules/motion_correction.rst

@@ -175,8 +175,9 @@ The high-level :py:func:`~spikeinterface.preprocessing.correct_motion()` is inte
     peaks = detect_peaks(recording=rec, method="locally_exclusive", detect_threshold=8.0, **job_kwargs)
     # (optional) sub-select some peaks to speed up the localization
     peaks = select_peaks(peaks=peaks, ...)
-    peak_locations = localize_peaks(recording=rec, peaks=peaks, method="monopolar_triangulation",radius_um=75.0,
-                                    max_distance_um=150.0, **job_kwargs)
+    peak_locations = localize_peaks(recording=rec, peaks=peaks, method="monopolar_triangulation",
+                                    method_kwargs(radius_um=75.0,max_distance_um=150.0),
+                                    job_kwargs=job_kwargs)
 
     # Step 2: motion inference
     motion = estimate_motion(

doc/modules/sortingcomponents.rst

@@ -56,8 +56,7 @@ follows:
         exclude_sweep_ms=0.2,
         noise_levels=None,
         random_chunk_kwargs={},
-        gather_mode='memory',
-        **job_kwargs,
+        job_kwargs=job_kwargs,
     )
 
 The output :code:`peaks` is a NumPy array with a length of the number of peaks found and the following dtype:
@@ -99,10 +98,12 @@ follows:
         recording=recording,
         peaks=peaks,
         method='center_of_mass',
-        radius_um=70.,
-        ms_before=0.3,
-        ms_after=0.6,
-        **job_kwargs
+        method_kwargs=dict(
+          radius_um=70.,
+          ms_before=0.3,
+          ms_after=0.6,
+        ),
+        job_kwargs=job_kwargs,
     )
 
 

examples/how_to/analyze_neuropixels.py

@@ -169,14 +169,18 @@
 from spikeinterface.sortingcomponents.peak_detection import detect_peaks
 
 job_kwargs = dict(n_jobs=40, chunk_duration='1s', progress_bar=True)
-peaks = detect_peaks(rec,  method='locally_exclusive', noise_levels=noise_levels_int16,
-                     detect_threshold=5, radius_um=50., **job_kwargs)
+peaks = detect_peaks(rec,
+                    method='locally_exclusive',
+                    method_kwargs=dict(
+                         noise_levels=noise_levels_int16,
+                     detect_threshold=5, radius_um=50.),
+                     job_kwargs=job_kwargs)
 peaks
 
 # +
 from spikeinterface.sortingcomponents.peak_localization import localize_peaks
 
-peak_locations = localize_peaks(rec, peaks, method='center_of_mass', radius_um=50., **job_kwargs)
+peak_locations = localize_peaks(rec, peaks, method='center_of_mass', method_kwargs=dict(radius_um=50.), job_kwargs=job_kwargs)
 # -
 
 # ### Check for drifts

examples/tutorials/widgets/plot_4_peaks_gallery.py

@@ -23,20 +23,20 @@
 
 from spikeinterface.sortingcomponents.peak_detection import detect_peaks
 
+si.set_global_job_kwargs(chunk_memory="10M", n_jobs=1, progress_bar=True)
 rec_filtered = si.bandpass_filter(recording=recording, freq_min=300.0, freq_max=6000.0, margin_ms=5.0)
 print(rec_filtered)
 peaks = detect_peaks(
     recording=rec_filtered,
     method="locally_exclusive",
-    peak_sign="neg",
-    detect_threshold=6,
-    exclude_sweep_ms=0.3,
-    radius_um=100,
-    noise_levels=None,
-    random_chunk_kwargs={},
-    chunk_memory="10M",
-    n_jobs=1,
-    progress_bar=True,
+    method_kwargs=dict(
+        peak_sign="neg",
+        detect_threshold=6,
+        exclude_sweep_ms=0.3,
+        radius_um=100,
+        noise_levels=None,
+    )
+
 )
 
 ##############################################################################

src/spikeinterface/benchmark/benchmark_clustering.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from spikeinterface.sortingcomponents.clustering import find_cluster_from_peaks
+from spikeinterface.sortingcomponents.clustering import find_clusters_from_peaks
 from spikeinterface.core import NumpySorting
 from spikeinterface.comparison import GroundTruthComparison
 from spikeinterface.widgets import (
@@ -30,8 +30,8 @@ def __init__(self, recording, gt_sorting, params, indices, peaks, exhaustive_gt=
         self.result = {}
 
     def run(self, **job_kwargs):
-        labels, peak_labels = find_cluster_from_peaks(
-            self.recording, self.peaks, method=self.method, method_kwargs=self.method_kwargs, **job_kwargs
+        labels, peak_labels = find_clusters_from_peaks(
+            self.recording, self.peaks, method=self.method, method_kwargs=self.method_kwargs, job_kwargs=job_kwargs
         )
         self.result["peak_labels"] = peak_labels
 

src/spikeinterface/benchmark/benchmark_matching.py

@@ -21,13 +21,14 @@ def __init__(self, recording, gt_sorting, params):
         self.recording = recording
         self.gt_sorting = gt_sorting
         self.method = params["method"]
-        self.templates = params["method_kwargs"]["templates"]
+        # self.templates = params["method_kwargs"]["templates"]
+        self.templates = params["templates"]
         self.method_kwargs = params["method_kwargs"]
         self.result = {}
 
     def run(self, **job_kwargs):
         spikes = find_spikes_from_templates(
-            self.recording, method=self.method, method_kwargs=self.method_kwargs, **job_kwargs
+            self.recording, self.templates, method=self.method, method_kwargs=self.method_kwargs, job_kwargs=job_kwargs
         )
         unit_ids = self.templates.unit_ids
         sorting = np.zeros(spikes.size, dtype=minimum_spike_dtype)

src/spikeinterface/benchmark/benchmark_motion_estimation.py

@@ -89,15 +89,19 @@ def run(self, **job_kwargs):
         noise_levels = get_noise_levels(self.recording, return_in_uV=False, **job_kwargs)
 
         t0 = time.perf_counter()
-        peaks = detect_peaks(self.recording, noise_levels=noise_levels, **p["detect_kwargs"], **job_kwargs)
+        detect_kwargs = p["detect_kwargs"].copy()
+        detect_kwargs["noise_levels"] = noise_levels
+        peaks = detect_peaks(self.recording, method_kwargs=detect_kwargs, job_kwargs=job_kwargs)
         t1 = time.perf_counter()
         if p["select_kwargs"] is not None:
             selected_peaks = select_peaks(self.peaks, **p["select_kwargs"], **job_kwargs)
         else:
             selected_peaks = peaks
 
         t2 = time.perf_counter()
-        peak_locations = localize_peaks(self.recording, selected_peaks, **p["localize_kwargs"], **job_kwargs)
+        peak_locations = localize_peaks(
+            self.recording, selected_peaks, method_kwargs=p["localize_kwargs"], job_kwargs=job_kwargs
+        )
         t3 = time.perf_counter()
         motion = estimate_motion(self.recording, selected_peaks, peak_locations, **p["estimate_motion_kwargs"])
         t4 = time.perf_counter()
@@ -240,6 +244,8 @@ def plot_drift(
 
             # ax0.set_ylim()
 
+        return fig
+
     def plot_errors(self, case_keys=None, figsize=None, lim=None):
         import matplotlib.pyplot as plt
 
@@ -305,6 +311,8 @@ def plot_errors(self, case_keys=None, figsize=None, lim=None):
             if lim is not None:
                 ax.set_ylim(0, lim)
 
+        return fig
+
     def plot_summary_errors(self, case_keys=None, show_legend=True, figsize=(15, 5)):
         import matplotlib.pyplot as plt
 
@@ -368,6 +376,8 @@ def plot_summary_errors(self, case_keys=None, show_legend=True, figsize=(15, 5))
 
         despine(ax2)
 
+        return fig
+
         # ax1.sharey(ax0)
         # ax2.sharey(ax0)
 

src/spikeinterface/benchmark/benchmark_peak_detection.py

@@ -33,7 +33,7 @@ def __init__(self, recording, gt_sorting, params, gt_peaks, exhaustive_gt=True,
         self.result = {}
 
     def run(self, **job_kwargs):
-        peaks = detect_peaks(self.recording, self.method, **self.params, **job_kwargs)
+        peaks = detect_peaks(self.recording, self.method, method_kwargs=self.params, job_kwargs=job_kwargs)
         self.result["peaks"] = peaks
 
     def compute_result(self, **result_params):

src/spikeinterface/benchmark/benchmark_peak_selection.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from spikeinterface.sortingcomponents.clustering import find_cluster_from_peaks
+from spikeinterface.sortingcomponents.clustering import find_clusters_from_peaks
 from spikeinterface.core import NumpySorting
 from spikeinterface.comparison import GroundTruthComparison
 from spikeinterface.comparison.comparisontools import make_matching_events