spikeinterface 0.101.2__tar.gz → 0.102.0__tar.gz

{spikeinterface-0.101.2/src/spikeinterface.egg-info → spikeinterface-0.102.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: spikeinterface
-Version: 0.101.2
+Version: 0.102.0
 Summary: Python toolkit for analysis, visualization, and comparison of spike sorting output
 Author-email: Alessio Buccino <alessiop.buccino@gmail.com>, Samuel Garcia <sam.garcia.die@gmail.com>
 Project-URL: homepage, https://github.com/SpikeInterface/spikeinterface
@@ -14,21 +14,21 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: OS Independent
-Requires-Python: <4.0,>=3.9
+Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy<2.0,>=1.20
+Requires-Dist: numpy>=1.20
 Requires-Dist: threadpoolctl>=3.0.0
 Requires-Dist: tqdm
-Requires-Dist: zarr<2.18,>=2.16
-Requires-Dist: neo>=0.13.0
+Requires-Dist: zarr<3,>=2.18
+Requires-Dist: neo>=0.14.0
 Requires-Dist: probeinterface>=0.2.23
 Requires-Dist: packaging
 Provides-Extra: extractors
 Requires-Dist: MEArec>=1.8; extra == "extractors"
 Requires-Dist: pynwb>=2.6.0; extra == "extractors"
-Requires-Dist: hdmf-zarr>=0.5.0; extra == "extractors"
-Requires-Dist: pyedflib>=0.1.30; extra == "extractors"
+Requires-Dist: hdmf-zarr>=0.11.0; extra == "extractors"
+Requires-Dist: pyedflib<0.1.39,>=0.1.30; extra == "extractors"
 Requires-Dist: sonpy; python_version < "3.10" and extra == "extractors"
 Requires-Dist: lxml; extra == "extractors"
 Requires-Dist: scipy; extra == "extractors"
@@ -37,13 +37,13 @@ Requires-Dist: ibllib>=2.36.0; extra == "extractors"
 Requires-Dist: pymatreader>=0.0.32; extra == "extractors"
 Requires-Dist: zugbruecke>=0.2; sys_platform != "win32" and extra == "extractors"
 Provides-Extra: streaming-extractors
-Requires-Dist: ONE-api>=2.7.0; extra == "streaming-extractors"
+Requires-Dist: ONE-api<2.10.0,>=2.7.0; extra == "streaming-extractors"
 Requires-Dist: ibllib>=2.36.0; extra == "streaming-extractors"
 Requires-Dist: pynwb>=2.6.0; extra == "streaming-extractors"
 Requires-Dist: fsspec; extra == "streaming-extractors"
 Requires-Dist: aiohttp; extra == "streaming-extractors"
 Requires-Dist: requests; extra == "streaming-extractors"
-Requires-Dist: hdmf-zarr>=0.5.0; extra == "streaming-extractors"
+Requires-Dist: hdmf-zarr>=0.11.0; extra == "streaming-extractors"
 Requires-Dist: remfile; extra == "streaming-extractors"
 Requires-Dist: s3fs; extra == "streaming-extractors"
 Provides-Extra: preprocessing
@@ -58,6 +58,8 @@ Requires-Dist: distinctipy; extra == "full"
 Requires-Dist: matplotlib>=3.6; extra == "full"
 Requires-Dist: cuda-python; platform_system != "Darwin" and extra == "full"
 Requires-Dist: numba; extra == "full"
+Requires-Dist: skops; extra == "full"
+Requires-Dist: huggingface_hub; extra == "full"
 Provides-Extra: widgets
 Requires-Dist: matplotlib; extra == "widgets"
 Requires-Dist: ipympl; extra == "widgets"
@@ -92,6 +94,8 @@ Requires-Dist: tridesclous>=1.6.8; extra == "test"
 Requires-Dist: pymde; extra == "test"
 Requires-Dist: torch; extra == "test"
 Requires-Dist: pynndescent; extra == "test"
+Requires-Dist: skops; extra == "test"
+Requires-Dist: huggingface_hub; extra == "test"
 Provides-Extra: docs
 Requires-Dist: Sphinx; extra == "docs"
 Requires-Dist: sphinx_rtd_theme>=1.2; extra == "docs"
@@ -105,6 +109,8 @@ Requires-Dist: pandas; extra == "docs"
 Requires-Dist: hdbscan>=0.8.33; extra == "docs"
 Requires-Dist: numba; extra == "docs"
 Requires-Dist: networkx; extra == "docs"
+Requires-Dist: skops; extra == "docs"
+Requires-Dist: scikit-learn; extra == "docs"
 Requires-Dist: pooch>=1.8.2; extra == "docs"
 Requires-Dist: datalad>=1.0.2; extra == "docs"
 Provides-Extra: dev

{spikeinterface-0.101.2 → spikeinterface-0.102.0}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "spikeinterface"
-version = "0.101.2"
+version = "0.102.0"
 authors = [
   { name="Alessio Buccino", email="alessiop.buccino@gmail.com" },
   { name="Samuel Garcia", email="sam.garcia.die@gmail.com" },
 ]
 description = "Python toolkit for analysis, visualization, and comparison of spike sorting output"
 readme = "README.md"
-requires-python = ">=3.9,<4.0"
+requires-python = ">=3.9,<3.13"
 classifiers = [
     "Programming Language :: Python :: 3 :: Only",
     "License :: OSI Approved :: MIT License",
@@ -20,11 +20,11 @@ classifiers = [
 
 
 dependencies = [
-    "numpy>=1.20, <2.0",  # 1.20 np.ptp, 1.26 might be necessary for avoiding pickling errors when numpy >2.0
+    "numpy>=1.20",
     "threadpoolctl>=3.0.0",
     "tqdm",
-    "zarr>=2.16,<2.18",
-    "neo>=0.13.0",
+    "zarr>=2.18,<3",
+    "neo>=0.14.0",
     "probeinterface>=0.2.23",
     "packaging",
 ]
@@ -61,8 +61,8 @@ changelog = "https://spikeinterface.readthedocs.io/en/latest/whatisnew.html"
 extractors = [
     "MEArec>=1.8",
     "pynwb>=2.6.0",
-    "hdmf-zarr>=0.5.0",
-    "pyedflib>=0.1.30",
+    "hdmf-zarr>=0.11.0",
+    "pyedflib>=0.1.30,<0.1.39",
     "sonpy;python_version<'3.10'",
     "lxml", # lxml for neuroscope
     "scipy",
@@ -73,14 +73,14 @@ extractors = [
 ]
 
 streaming_extractors = [
-    "ONE-api>=2.7.0", # alf sorter and streaming IBL
+    "ONE-api>=2.7.0,<2.10.0", # alf sorter and streaming IBL
     "ibllib>=2.36.0", # streaming IBL
     # Following dependencies are for streaming with nwb files
     "pynwb>=2.6.0",
     "fsspec",
     "aiohttp",
     "requests",
-    "hdmf-zarr>=0.5.0",
+    "hdmf-zarr>=0.11.0",
     "remfile",
     "s3fs"
 ]
@@ -101,6 +101,8 @@ full = [
     "matplotlib>=3.6", # matplotlib.colormaps
     "cuda-python; platform_system != 'Darwin'",
     "numba",
+    "skops",
+    "huggingface_hub"
 ]
 
 widgets = [
@@ -171,6 +173,10 @@ test = [
     "torch",
     "pynndescent",
 
+    # curation
+    "skops",
+    "huggingface_hub",
+
     # for github test : probeinterface and neo from master
     # for release we need pypi, so this need to be commented
     # "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",
@@ -192,6 +198,8 @@ docs = [
     "hdbscan>=0.8.33",   # For sorters spykingcircus2 + tridesclous
     "numba", # For many postprocessing functions
     "networkx",
+    "skops", # For auotmated curation
+    "scikit-learn", # For auotmated curation
     # Download data
     "pooch>=1.8.2",
     "datalad>=1.0.2",

{spikeinterface-0.101.2 → spikeinterface-0.102.0}/src/spikeinterface/__init__.py

@@ -1,7 +1,4 @@
-"""
-
-
-"""
+""" """
 
 import importlib.metadata
 

spikeinterface-0.102.0/src/spikeinterface/benchmark/__init__.py

@@ -0,0 +1,7 @@
+"""
+Module to benchmark:
+  * sorters
+  * some sorting components (clustering, motion, template matching)
+"""
+
+from .benchmark_sorter import SorterStudy

spikeinterface-0.101.2/src/spikeinterface/sortingcomponents/benchmark/benchmark_tools.py → spikeinterface-0.102.0/src/spikeinterface/benchmark/benchmark_base.py

@@ -11,7 +11,7 @@ import time
 
 from spikeinterface.core import SortingAnalyzer
 
-from spikeinterface import load_extractor, create_sorting_analyzer, load_sorting_analyzer
+from spikeinterface import load, create_sorting_analyzer, load_sorting_analyzer
 from spikeinterface.widgets import get_some_colors
 
 
@@ -131,7 +131,7 @@ class BenchmarkStudy:
 
         return cls(study_folder)
 
-    def create_benchmark(self):
+    def create_benchmark(self, key):
         raise NotImplementedError
 
     def scan_folder(self):
@@ -150,13 +150,13 @@ class BenchmarkStudy:
             analyzer = load_sorting_analyzer(folder)
             self.analyzers[key] = analyzer
             # the sorting is in memory here we take the saved one because comparisons need to pickle it later
-            sorting = load_extractor(analyzer.folder / "sorting")
+            sorting = load(analyzer.folder / "sorting")
             self.datasets[key] = analyzer.recording, sorting
 
         # for rec_file in (self.folder / "datasets" / "recordings").glob("*.pickle"):
         #     key = rec_file.stem
-        #     rec = load_extractor(rec_file)
-        #     gt_sorting = load_extractor(self.folder / f"datasets" / "gt_sortings" / key)
+        #     rec = load(rec_file)
+        #     gt_sorting = load(self.folder / f"datasets" / "gt_sortings" / key)
         #     self.datasets[key] = (rec, gt_sorting)
 
         with open(self.folder / "cases.pickle", "rb") as f:
@@ -208,10 +208,11 @@ class BenchmarkStudy:
         for key in case_keys:
 
             result_folder = self.folder / "results" / self.key_to_str(key)
+            sorter_folder = self.folder / "sorters" / self.key_to_str(key)
 
             if keep and result_folder.exists():
                 continue
-            elif not keep and result_folder.exists():
+            elif not keep and (result_folder.exists() or sorter_folder.exists()):
                 self.remove_benchmark(key)
             job_keys.append(key)
 
@@ -258,25 +259,9 @@ class BenchmarkStudy:
         return df
 
     def plot_run_times(self, case_keys=None):
-        if case_keys is None:
-            case_keys = list(self.cases.keys())
-        run_times = self.get_run_times(case_keys=case_keys)
-
-        colors = self.get_colors()
-        import matplotlib.pyplot as plt
+        from .benchmark_plot_tools import plot_run_times
 
-        fig, ax = plt.subplots()
-        labels = []
-        for i, key in enumerate(case_keys):
-            labels.append(self.cases[key]["label"])
-            rt = run_times.at[key, "run_times"]
-            ax.bar(i, rt, width=0.8, color=colors[key])
-        ax.set_xticks(np.arange(len(case_keys)))
-        ax.set_xticklabels(labels, rotation=45.0)
-        return fig
-
-        # ax = run_times.plot(kind="bar")
-        # return ax.figure
+        return plot_run_times(self, case_keys=case_keys)
 
     def compute_results(self, case_keys=None, verbose=False, **result_params):
         if case_keys is None:
@@ -443,9 +428,9 @@ class Benchmark:
             elif format == "sorting":
                 from spikeinterface.core import load_extractor
 
-                result[k] = load_extractor(folder / k)
+                result[k] = load(folder / k)
             elif format == "Motion":
-                from spikeinterface.sortingcomponents.motion import Motion
+                from spikeinterface.core.motion import Motion
 
                 result[k] = Motion.load(folder / k)
             elif format == "zarr_templates":
@@ -462,10 +447,3 @@ class Benchmark:
     def compute_result(self):
         # run becnhmark result
         raise NotImplementedError
-
-
-def _simpleaxis(ax):
-    ax.spines["top"].set_visible(False)
-    ax.spines["right"].set_visible(False)
-    ax.get_xaxis().tick_bottom()
-    ax.get_yaxis().tick_left()

{spikeinterface-0.101.2/src/spikeinterface/sortingcomponents → spikeinterface-0.102.0/src/spikeinterface}/benchmark/benchmark_clustering.py

@@ -11,8 +11,7 @@ from spikeinterface.widgets import (
 
 import numpy as np
 
-
-from .benchmark_tools import BenchmarkStudy, Benchmark
+from .benchmark_base import Benchmark, BenchmarkStudy
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.template_tools import get_template_extremum_channel
 
@@ -161,49 +160,21 @@ class ClusteringStudy(BenchmarkStudy):
 
         return count_units
 
-    def plot_unit_counts(self, case_keys=None, figsize=None, **extra_kwargs):
-        from spikeinterface.widgets.widget_list import plot_study_unit_counts
+    # plotting by methods
+    def plot_unit_counts(self, **kwargs):
+        from .benchmark_plot_tools import plot_unit_counts
 
-        plot_study_unit_counts(self, case_keys, figsize=figsize, **extra_kwargs)
+        return plot_unit_counts(self, **kwargs)
 
-    def plot_agreements(self, case_keys=None, figsize=(15, 15)):
-        if case_keys is None:
-            case_keys = list(self.cases.keys())
-        import pylab as plt
+    def plot_agreement_matrix(self, **kwargs):
+        from .benchmark_plot_tools import plot_agreement_matrix
 
-        fig, axs = plt.subplots(ncols=len(case_keys), nrows=1, figsize=figsize, squeeze=False)
+        return plot_agreement_matrix(self, **kwargs)
 
-        for count, key in enumerate(case_keys):
-            ax = axs[0, count]
-            ax.set_title(self.cases[key]["label"])
-            plot_agreement_matrix(self.get_result(key)["gt_comparison"], ax=ax)
+    def plot_performances_vs_snr(self, **kwargs):
+        from .benchmark_plot_tools import plot_performances_vs_snr
 
-        return fig
-
-    def plot_performances_vs_snr(self, case_keys=None, figsize=(15, 15)):
-        if case_keys is None:
-            case_keys = list(self.cases.keys())
-        import pylab as plt
-
-        fig, axes = plt.subplots(ncols=1, nrows=3, figsize=figsize)
-
-        for count, k in enumerate(("accuracy", "recall", "precision")):
-
-            ax = axes[count]
-            for key in case_keys:
-                label = self.cases[key]["label"]
-
-                analyzer = self.get_sorting_analyzer(key)
-                metrics = analyzer.get_extension("quality_metrics").get_data()
-                x = metrics["snr"].values
-                y = self.get_result(key)["gt_comparison"].get_performance()[k].values
-                ax.scatter(x, y, marker=".", label=label)
-                ax.set_title(k)
-
-            if count == 2:
-                ax.legend()
-
-        return fig
+        return plot_performances_vs_snr(self, **kwargs)
 
     def plot_error_metrics(self, metric="cosine", case_keys=None, figsize=(15, 5)):
 

{spikeinterface-0.101.2/src/spikeinterface/sortingcomponents → spikeinterface-0.102.0/src/spikeinterface}/benchmark/benchmark_matching.py

@@ -9,11 +9,8 @@ from spikeinterface.widgets import (
 )
 
 import numpy as np
-from spikeinterface.sortingcomponents.benchmark.benchmark_tools import Benchmark, BenchmarkStudy
+from .benchmark_base import Benchmark, BenchmarkStudy
 from spikeinterface.core.basesorting import minimum_spike_dtype
-from spikeinterface.sortingcomponents.tools import remove_empty_templates
-from spikeinterface.core.recording_tools import get_noise_levels
-from spikeinterface.core.sparsity import compute_sparsity
 
 
 class MatchingBenchmark(Benchmark):
@@ -36,7 +33,7 @@ class MatchingBenchmark(Benchmark):
         sorting["unit_index"] = spikes["cluster_index"]
         sorting["segment_index"] = spikes["segment_index"]
         sorting = NumpySorting(sorting, self.recording.sampling_frequency, unit_ids)
-        self.result = {"sorting": sorting}
+        self.result = {"sorting": sorting, "spikes": spikes}
         self.result["templates"] = self.templates
 
     def compute_result(self, with_collision=False, **result_params):
@@ -48,6 +45,7 @@ class MatchingBenchmark(Benchmark):
 
     _run_key_saved = [
         ("sorting", "sorting"),
+        ("spikes", "npy"),
         ("templates", "zarr_templates"),
     ]
     _result_key_saved = [("gt_collision", "pickle"), ("gt_comparison", "pickle")]
@@ -64,45 +62,25 @@ class MatchingStudy(BenchmarkStudy):
         benchmark = MatchingBenchmark(recording, gt_sorting, params)
         return benchmark
 
-    def plot_agreements(self, case_keys=None, figsize=None):
-        if case_keys is None:
-            case_keys = list(self.cases.keys())
-        import pylab as plt
-
-        fig, axs = plt.subplots(ncols=len(case_keys), nrows=1, figsize=figsize, squeeze=False)
-
-        for count, key in enumerate(case_keys):
-            ax = axs[0, count]
-            ax.set_title(self.cases[key]["label"])
-            plot_agreement_matrix(self.get_result(key)["gt_comparison"], ax=ax)
-
-    def plot_performances_vs_snr(self, case_keys=None, figsize=None, metrics=["accuracy", "recall", "precision"]):
-        if case_keys is None:
-            case_keys = list(self.cases.keys())
+    def plot_agreement_matrix(self, **kwargs):
+        from .benchmark_plot_tools import plot_agreement_matrix
 
-        fig, axs = plt.subplots(ncols=1, nrows=len(metrics), figsize=figsize, squeeze=False)
+        return plot_agreement_matrix(self, **kwargs)
 
-        for count, k in enumerate(metrics):
+    def plot_performances_vs_snr(self, **kwargs):
+        from .benchmark_plot_tools import plot_performances_vs_snr
 
-            ax = axs[count, 0]
-            for key in case_keys:
-                label = self.cases[key]["label"]
+        return plot_performances_vs_snr(self, **kwargs)
 
-                analyzer = self.get_sorting_analyzer(key)
-                metrics = analyzer.get_extension("quality_metrics").get_data()
-                x = metrics["snr"].values
-                y = self.get_result(key)["gt_comparison"].get_performance()[k].values
-                ax.scatter(x, y, marker=".", label=label)
-                ax.set_title(k)
+    def plot_performances_comparison(self, **kwargs):
+        from .benchmark_plot_tools import plot_performances_comparison
 
-            if count == 2:
-                ax.legend()
-
-        return fig
+        return plot_performances_comparison(self, **kwargs)
 
     def plot_collisions(self, case_keys=None, figsize=None):
         if case_keys is None:
             case_keys = list(self.cases.keys())
+        import matplotlib.pyplot as plt
 
         fig, axs = plt.subplots(ncols=len(case_keys), nrows=1, figsize=figsize, squeeze=False)
 
@@ -119,70 +97,6 @@ class MatchingStudy(BenchmarkStudy):
 
         return fig
 
-    def plot_comparison_matching(
-        self,
-        case_keys=None,
-        performance_names=["accuracy", "recall", "precision"],
-        colors=["g", "b", "r"],
-        ylim=(-0.1, 1.1),
-        figsize=None,
-    ):
-
-        if case_keys is None:
-            case_keys = list(self.cases.keys())
-
-        num_methods = len(case_keys)
-        import pylab as plt
-
-        fig, axs = plt.subplots(ncols=num_methods, nrows=num_methods, figsize=(10, 10))
-        for i, key1 in enumerate(case_keys):
-            for j, key2 in enumerate(case_keys):
-                if len(axs.shape) > 1:
-                    ax = axs[i, j]
-                else:
-                    ax = axs[j]
-                comp1 = self.get_result(key1)["gt_comparison"]
-                comp2 = self.get_result(key2)["gt_comparison"]
-                if i <= j:
-                    for performance, color in zip(performance_names, colors):
-                        perf1 = comp1.get_performance()[performance]
-                        perf2 = comp2.get_performance()[performance]
-                        ax.plot(perf2, perf1, ".", label=performance, color=color)
-
-                    ax.plot([0, 1], [0, 1], "k--", alpha=0.5)
-                    ax.set_ylim(ylim)
-                    ax.set_xlim(ylim)
-                    ax.spines[["right", "top"]].set_visible(False)
-                    ax.set_aspect("equal")
-
-                    label1 = self.cases[key1]["label"]
-                    label2 = self.cases[key2]["label"]
-                    if j == i:
-                        ax.set_ylabel(f"{label1}")
-                    else:
-                        ax.set_yticks([])
-                    if i == j:
-                        ax.set_xlabel(f"{label2}")
-                    else:
-                        ax.set_xticks([])
-                    if i == num_methods - 1 and j == num_methods - 1:
-                        patches = []
-                        import matplotlib.patches as mpatches
-
-                        for color, name in zip(colors, performance_names):
-                            patches.append(mpatches.Patch(color=color, label=name))
-                        ax.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
-                else:
-                    ax.spines["bottom"].set_visible(False)
-                    ax.spines["left"].set_visible(False)
-                    ax.spines["top"].set_visible(False)
-                    ax.spines["right"].set_visible(False)
-                    ax.set_xticks([])
-                    ax.set_yticks([])
-        plt.tight_layout(h_pad=0, w_pad=0)
-
-        return fig
-
     def get_count_units(self, case_keys=None, well_detected_score=None, redundant_score=None, overmerged_score=None):
         import pandas as pd
 
@@ -225,6 +139,7 @@ class MatchingStudy(BenchmarkStudy):
         plot_study_unit_counts(self, case_keys, figsize=figsize)
 
     def plot_unit_losses(self, before, after, metric=["precision"], figsize=None):
+        import matplotlib.pyplot as plt
 
         fig, axs = plt.subplots(ncols=1, nrows=len(metric), figsize=figsize, squeeze=False)
 

{spikeinterface-0.101.2/src/spikeinterface/sortingcomponents → spikeinterface-0.102.0/src/spikeinterface}/benchmark/benchmark_motion_estimation.py

@@ -8,14 +8,15 @@ import time
 import numpy as np
 
 from spikeinterface.core import get_noise_levels
-from spikeinterface.sortingcomponents.benchmark.benchmark_tools import Benchmark, BenchmarkStudy, _simpleaxis
+from spikeinterface.core.motion import Motion
 from spikeinterface.sortingcomponents.motion import estimate_motion
 from spikeinterface.sortingcomponents.peak_detection import detect_peaks
 from spikeinterface.sortingcomponents.peak_selection import select_peaks
 from spikeinterface.sortingcomponents.peak_localization import localize_peaks
 from spikeinterface.widgets import plot_probe_map
 
-from spikeinterface.sortingcomponents.motion import Motion
+from .benchmark_base import Benchmark, BenchmarkStudy
+from .benchmark_plot_tools import _simpleaxis
 
 # import MEArec as mr
 
@@ -108,6 +109,8 @@ class MotionEstimationBenchmark(Benchmark):
             estimate_motion=t4 - t3,
         )
 
+        self.result["peaks"] = peaks
+        self.result["peak_locations"] = peak_locations
         self.result["step_run_times"] = step_run_times
         self.result["raw_motion"] = motion
 
@@ -130,6 +133,8 @@ class MotionEstimationBenchmark(Benchmark):
         self.result["motion"] = motion
 
     _run_key_saved = [
+        ("peaks", "npy"),
+        ("peak_locations", "npy"),
         ("raw_motion", "Motion"),
         ("step_run_times", "pickle"),
     ]
@@ -160,7 +165,9 @@ class MotionEstimationStudy(BenchmarkStudy):
     def plot_true_drift(self, case_keys=None, scaling_probe=1.5, figsize=(8, 6)):
         self.plot_drift(case_keys=case_keys, tested_drift=False, scaling_probe=scaling_probe, figsize=figsize)
 
-    def plot_drift(self, case_keys=None, gt_drift=True, tested_drift=True, scaling_probe=1.0, figsize=(8, 6)):
+    def plot_drift(
+        self, case_keys=None, gt_drift=True, tested_drift=True, raster=False, scaling_probe=1.0, figsize=(8, 6)
+    ):
         import matplotlib.pyplot as plt
 
         if case_keys is None:
@@ -194,6 +201,13 @@ class MotionEstimationStudy(BenchmarkStudy):
 
             # for i in range(self.gt_unit_positions.shape[1]):
             #     ax.plot(temporal_bins_s, self.gt_unit_positions[:, i], alpha=0.5, ls="--", c="0.5")
+            if raster:
+                peaks = bench.result["peaks"]
+                peak_locations = bench.result["peak_locations"]
+                rec = bench.recording
+                x = peaks["sample_index"] / rec.sampling_frequency
+                y = peak_locations[bench.direction]
+                ax.scatter(x, y, alpha=0.2, s=2, c=np.abs(peaks["amplitude"]), cmap="inferno")
 
             for i in range(gt_motion.displacement[0].shape[1]):
                 depth = motion.spatial_bins_um[i]

{spikeinterface-0.101.2/src/spikeinterface/sortingcomponents → spikeinterface-0.102.0/src/spikeinterface}/benchmark/benchmark_motion_interpolation.py

@@ -10,7 +10,7 @@ from spikeinterface.sortingcomponents.motion.motion_interpolation import Interpo
 from spikeinterface.curation import MergeUnitsSorting
 
 
-from spikeinterface.sortingcomponents.benchmark.benchmark_tools import Benchmark, BenchmarkStudy, _simpleaxis
+from .benchmark_base import Benchmark, BenchmarkStudy
 
 
 class MotionInterpolationBenchmark(Benchmark):

{spikeinterface-0.101.2/src/spikeinterface/sortingcomponents → spikeinterface-0.102.0/src/spikeinterface}/benchmark/benchmark_peak_detection.py

@@ -12,10 +12,9 @@ from spikeinterface.core import get_noise_levels
 
 import numpy as np
 
-from spikeinterface.sortingcomponents.benchmark.benchmark_tools import Benchmark, BenchmarkStudy
+from .benchmark_base import Benchmark, BenchmarkStudy
 from spikeinterface.core.basesorting import minimum_spike_dtype
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
-from spikeinterface.core.template_tools import get_template_extremum_channel
 
 
 class PeakDetectionBenchmark(Benchmark):

{spikeinterface-0.101.2/src/spikeinterface/sortingcomponents → spikeinterface-0.102.0/src/spikeinterface}/benchmark/benchmark_peak_localization.py

@@ -6,7 +6,7 @@ from spikeinterface.postprocessing.localization_tools import (
     compute_grid_convolution,
 )
 import numpy as np
-from spikeinterface.sortingcomponents.benchmark.benchmark_tools import Benchmark, BenchmarkStudy
+from .benchmark_base import Benchmark, BenchmarkStudy
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 
 

{spikeinterface-0.101.2/src/spikeinterface/sortingcomponents → spikeinterface-0.102.0/src/spikeinterface}/benchmark/benchmark_peak_selection.py

@@ -6,15 +6,9 @@ from spikeinterface.comparison import GroundTruthComparison
 from spikeinterface.comparison.comparisontools import make_matching_events
 from spikeinterface.core import get_noise_levels
 
-import time
-import string, random
-import pylab as plt
-import os
 import numpy as np
 
-from spikeinterface.sortingcomponents.benchmark.benchmark_tools import Benchmark, BenchmarkStudy
-from spikeinterface.core.basesorting import minimum_spike_dtype
-from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
+from .benchmark_base import Benchmark, BenchmarkStudy
 
 
 class PeakSelectionBenchmark(Benchmark):