spikeinterface 0.103.1__tar.gz → 0.103.2__tar.gz

{spikeinterface-0.103.1/src/spikeinterface.egg-info → spikeinterface-0.103.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spikeinterface
-Version: 0.103.1
+Version: 0.103.2
 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,7 +14,7 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: OS Independent
-Requires-Python: <3.14,>=3.9
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.20; python_version < "3.13"

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "spikeinterface"
-version = "0.103.1"
+version = "0.103.2"
 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,<3.14"
+requires-python = ">=3.9"
 classifiers = [
     "Programming Language :: Python :: 3 :: Only",
     "License :: OSI Approved :: MIT License",

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/benchmark/benchmark_base.py

@@ -431,7 +431,7 @@ class BenchmarkStudy:
             if verbose:
                 print("### Compute result", key, "###")
             benchmark = self.benchmarks[key]
-            assert benchmark is not None
+            assert benchmark is not None, f"Benchmkark for key {key} has not been run yet!"
             benchmark.compute_result(**result_params)
             benchmark.save_result(self.folder / "results" / self.key_to_str(key))
 

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/core/analyzer_extension_core.py

@@ -437,6 +437,7 @@ class ComputeTemplates(AnalyzerExtension):
             return_in_uV = self.sorting_analyzer.return_in_uV
 
             return_std = "std" in self.params["operators"]
+            sparsity_mask = None if self.sparsity is None else self.sparsity.mask
             output = estimate_templates_with_accumulator(
                 recording,
                 some_spikes,
@@ -445,17 +446,24 @@ class ComputeTemplates(AnalyzerExtension):
                 self.nafter,
                 return_in_uV=return_in_uV,
                 return_std=return_std,
+                sparsity_mask=sparsity_mask,
                 verbose=verbose,
                 **job_kwargs,
             )
 
-            # Output of estimate_templates_with_accumulator is either (templates,) or (templates, stds)
             if return_std:
                 templates, stds = output
-                self.data["average"] = templates
-                self.data["std"] = stds
+                data = dict(average=templates, std=stds)
             else:
-                self.data["average"] = output
+                templates = output
+                data = dict(average=templates)
+
+            if self.sparsity is not None:
+                # make average and std dense again
+                for k, arr in data.items():
+                    dense_arr = self.sparsity.densify_templates(arr)
+                    data[k] = dense_arr
+            self.data.update(data)
 
     def _compute_and_append_from_waveforms(self, operators):
         if not self.sorting_analyzer.has_extension("waveforms"):

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/core/base.py

@@ -879,7 +879,7 @@ class BaseExtractor:
         self,
         name: str | None = None,
         folder: str | Path | None = None,
-        overwrite: str = False,
+        overwrite: bool = False,
         verbose: bool = True,
         **save_kwargs,
     ):

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/core/sortinganalyzer.py

@@ -1023,7 +1023,7 @@ class SortingAnalyzer:
                 # merge units
                 all_unit_ids = unit_ids
                 sparsity_mask = np.zeros((len(all_unit_ids), self.sparsity.mask.shape[1]), dtype=bool)
-                mergeable, masks = self.are_units_mergeable(
+                _, masks = self.are_units_mergeable(
                     merge_unit_groups,
                     sparsity_overlap=sparsity_overlap,
                     merging_mode=merging_mode,
@@ -1033,14 +1033,7 @@ class SortingAnalyzer:
                 for unit_index, unit_id in enumerate(all_unit_ids):
                     if unit_id in merge_new_unit_ids:
                         merge_unit_group = tuple(merge_unit_groups[merge_new_unit_ids.index(unit_id)])
-                        if not mergeable[merge_unit_group]:
-                            raise Exception(
-                                f"The sparsity of {merge_unit_group} do not overlap enough for a soft merge using "
-                                f"a sparsity threshold of {sparsity_overlap}. You can either lower the threshold or use "
-                                "a hard merge."
-                            )
-                        else:
-                            sparsity_mask[unit_index] = masks[merge_unit_group]
+                        sparsity_mask[unit_index] = masks[merge_unit_group]
                     else:
                         # This means that the unit is already in the previous sorting
                         index = self.sorting.id_to_index(unit_id)
@@ -1271,6 +1264,7 @@ class SortingAnalyzer:
         censor_ms: float | None = None,
         merging_mode: str = "soft",
         sparsity_overlap: float = 0.75,
+        raise_error_if_overlap_fails: bool = True,
         new_id_strategy: str = "append",
         return_new_unit_ids: bool = False,
         format: str = "memory",
@@ -1300,7 +1294,10 @@ class SortingAnalyzer:
             reloading waveforms if needed
         sparsity_overlap : float, default 0.75
             The percentage of overlap that units should share in order to accept merges. If this criteria is not
-            achieved, soft merging will not be possible and an error will be raised
+            achieved for a pair of units, soft merging will not be applied to them.
+        raise_error_if_overlap_fails : bool, default: True
+            If True and `sparsity_overlap` fails for any unit merges, this will raise an error. If False, units which fail the
+            `sparsity_overlap` threshold will be skipped in the merge.
         new_id_strategy : "append" | "take_first", default: "append"
             The strategy that should be used, if `new_unit_ids` is None, to create new unit_ids.
 
@@ -1333,15 +1330,43 @@ class SortingAnalyzer:
             if len(units) < 2:
                 raise ValueError("Merging requires at least two units to merge")
 
+        # remove units which do not pass the sparsity threshold
+        if self.sparsity is not None and merging_mode == "soft":
+
+            mergeable = self.are_units_mergeable(
+                merge_unit_groups,
+                sparsity_overlap=sparsity_overlap,
+                merging_mode=merging_mode,
+                return_masks=False,
+            )
+
+            mergeable_unit_groups = []
+            unmergeable_unit_groups = []
+            for merge_unit_group, mergeable in zip(merge_unit_groups, mergeable.values()):
+                if mergeable:
+                    mergeable_unit_groups.append(merge_unit_group)
+                else:
+                    unmergeable_unit_groups.append(merge_unit_group)
+
+            if len(unmergeable_unit_groups) > 0:
+                if raise_error_if_overlap_fails:
+                    error_message = f"The sparsity of the units in the merge groups {unmergeable_unit_groups} do not overlap enough for a soft merge using a sparsity threshold of {sparsity_overlap}. Either lower your `sparsity_overlap` or use the flag `raise_error_if_overlap_fails = False` to skip these units in your merge."
+                    raise Exception(error_message)
+                else:
+                    warning_message = f"The sparsity of the units in the merge groups {unmergeable_unit_groups} do not overlap enough for a soft merge using a sparsity threshold of {sparsity_overlap}. They will not be merged."
+                    warnings.warn(warning_message)
+        else:
+            mergeable_unit_groups = merge_unit_groups
+
         new_unit_ids = generate_unit_ids_for_merge_group(
-            self.unit_ids, merge_unit_groups, new_unit_ids, new_id_strategy
+            self.unit_ids, mergeable_unit_groups, new_unit_ids, new_id_strategy
         )
-        all_unit_ids = _get_ids_after_merging(self.unit_ids, merge_unit_groups, new_unit_ids=new_unit_ids)
+        all_unit_ids = _get_ids_after_merging(self.unit_ids, mergeable_unit_groups, new_unit_ids=new_unit_ids)
 
         new_analyzer = self._save_or_select_or_merge_or_split(
             format=format,
             folder=folder,
-            merge_unit_groups=merge_unit_groups,
+            merge_unit_groups=mergeable_unit_groups,
             unit_ids=all_unit_ids,
             censor_ms=censor_ms,
             merging_mode=merging_mode,

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/core/sparsity.py

@@ -247,6 +247,18 @@ class ChannelSparsity:
 
         return sparse_templates
 
+    def densify_templates(self, templates_array: np.ndarray) -> np.ndarray:
+        assert templates_array.shape[0] == self.num_units
+
+        densified_shape = (self.num_units, templates_array.shape[1], self.num_channels)
+        dense_templates = np.zeros(shape=densified_shape, dtype=templates_array.dtype)
+        for unit_index, unit_id in enumerate(self.unit_ids):
+            sparse_template = templates_array[unit_index, ...]
+            dense_template = self.densify_waveforms(waveforms=sparse_template[np.newaxis, :, :], unit_id=unit_id)
+            dense_templates[unit_index, :, :] = dense_template
+
+        return dense_templates
+
     @classmethod
     def from_unit_id_to_channel_ids(cls, unit_id_to_channel_ids, unit_ids, channel_ids):
         """

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/core/template_tools.py

@@ -44,7 +44,6 @@ def get_dense_templates_array(one_object: Templates | SortingAnalyzer, return_in
             raise ValueError("SortingAnalyzer need extension 'templates' to be computed to retrieve templates")
     else:
         raise ValueError("Input should be Templates or SortingAnalyzer")
-
     return templates_array
 
 

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/core/waveform_tools.py

@@ -505,7 +505,11 @@ def extract_waveforms_to_single_buffer(
 
     n_samples = nbefore + nafter
 
-    dtype = np.dtype(dtype)
+    if dtype is None:
+        dtype = recording.get_dtype()
+    else:
+        dtype = np.dtype(dtype)
+
     if mode == "shared_memory":
         assert file_path is None
     else:
@@ -537,7 +541,7 @@ def extract_waveforms_to_single_buffer(
 
     job_kwargs = fix_job_kwargs(job_kwargs)
 
-    if num_spikes > 0:
+    if num_spikes > 0 and num_chans > 0:
         # and run
         func = _worker_distribute_single_buffer
         init_func = _init_worker_distribute_single_buffer
@@ -564,11 +568,14 @@ def extract_waveforms_to_single_buffer(
         return all_waveforms
     elif mode == "shared_memory":
         if copy:
+            wf_out = all_waveforms.copy()
+            del all_waveforms
             if shm is not None:
                 # release all sharedmem buffer
                 # empty array have None
+                shm.close()
                 shm.unlink()
-            return all_waveforms.copy()
+            return wf_out
         else:
             return all_waveforms, wf_array_info
 
@@ -744,12 +751,13 @@ def estimate_templates(
     operator: str = "average",
     return_scaled=None,
     return_in_uV=True,
+    sparsity_mask=None,
     job_name=None,
     **job_kwargs,
 ):
     """
     Estimate dense templates with "average" or "median".
-    If "average" internally estimate_templates_with_accumulator() is used to saved memory/
+    If "average" internally estimate_templates_with_accumulator() is used to saved memory.
 
     Parameters
     ----------
@@ -770,6 +778,8 @@ def estimate_templates(
     return_in_uV : bool, default: True
         If True and the recording has scaling (gain_to_uV and offset_to_uV properties),
         traces are scaled to uV
+    sparsity_mask: None or array of bool, default: None
+        If not None shape must be must be (len(unit_ids), len(channel_ids))
 
     Returns
     -------
@@ -791,7 +801,15 @@ def estimate_templates(
 
     if operator == "average":
         templates_array = estimate_templates_with_accumulator(
-            recording, spikes, unit_ids, nbefore, nafter, return_in_uV=return_in_uV, job_name=job_name, **job_kwargs
+            recording,
+            spikes,
+            unit_ids,
+            nbefore,
+            nafter,
+            return_in_uV=return_in_uV,
+            sparsity_mask=sparsity_mask,
+            job_name=job_name,
+            **job_kwargs,
         )
     elif operator == "median":
         all_waveforms, wf_array_info = extract_waveforms_to_single_buffer(
@@ -802,6 +820,8 @@ def estimate_templates(
             nafter,
             mode="shared_memory",
             return_in_uV=return_in_uV,
+            dtype="float32",
+            sparsity_mask=sparsity_mask,
             copy=False,
             **job_kwargs,
         )
@@ -812,6 +832,8 @@ def estimate_templates(
             wfs = all_waveforms[spikes["unit_index"] == unit_index]
             templates_array[unit_index, :, :] = np.median(wfs, axis=0)
         # release shared memory after the median
+        del all_waveforms
+        wf_array_info["shm"].close()
         wf_array_info["shm"].unlink()
 
     else:
@@ -828,6 +850,7 @@ def estimate_templates_with_accumulator(
     nafter: int,
     return_scaled=None,
     return_in_uV=True,
+    sparsity_mask=None,
     job_name=None,
     return_std: bool = False,
     verbose: bool = False,
@@ -859,6 +882,8 @@ def estimate_templates_with_accumulator(
     return_in_uV : bool, default: True
         If True and the recording has scaling (gain_to_uV and offset_to_uV properties),
         traces are scaled to uV
+    sparsity_mask: None or array of bool, default: None
+        If not None shape must be must be (len(unit_ids), len(channel_ids))
     return_std: bool, default: False
         If True, the standard deviation is also computed.
 
@@ -882,10 +907,14 @@ def estimate_templates_with_accumulator(
     job_kwargs = fix_job_kwargs(job_kwargs)
     num_worker = job_kwargs["n_jobs"]
 
-    num_chans = recording.get_num_channels()
+    if sparsity_mask is None:
+        num_chans = int(recording.get_num_channels())
+    else:
+        num_chans = int(max(np.sum(sparsity_mask, axis=1)))  # This is a numpy scalar, so we cast to int
     num_units = len(unit_ids)
 
     shape = (num_worker, num_units, nbefore + nafter, num_chans)
+
     dtype = np.dtype("float32")
     waveform_accumulator_per_worker, shm = make_shared_array(shape, dtype)
     shm_name = shm.name
@@ -909,6 +938,7 @@ def estimate_templates_with_accumulator(
         nbefore,
         nafter,
         return_in_uV,
+        sparsity_mask,
     )
 
     if job_name is None:
@@ -965,6 +995,7 @@ def _init_worker_estimate_templates(
     nbefore,
     nafter,
     return_in_uV,
+    sparsity_mask,
 ):
     worker_dict = {}
     worker_dict["recording"] = recording
@@ -972,6 +1003,7 @@ def _init_worker_estimate_templates(
     worker_dict["nbefore"] = nbefore
     worker_dict["nafter"] = nafter
     worker_dict["return_in_uV"] = return_in_uV
+    worker_dict["sparsity_mask"] = sparsity_mask
 
     from multiprocessing.shared_memory import SharedMemory
     import multiprocessing
@@ -1009,6 +1041,7 @@ def _worker_estimate_templates(segment_index, start_frame, end_frame, worker_dic
     waveform_squared_accumulator_per_worker = worker_dict.get("waveform_squared_accumulator_per_worker", None)
     worker_index = worker_dict["worker_index"]
     return_in_uV = worker_dict["return_in_uV"]
+    sparsity_mask = worker_dict["sparsity_mask"]
 
     seg_size = recording.get_num_samples(segment_index=segment_index)
 
@@ -1040,6 +1073,14 @@ def _worker_estimate_templates(segment_index, start_frame, end_frame, worker_dic
             unit_index = spikes[spike_index]["unit_index"]
             wf = traces[sample_index - start - nbefore : sample_index - start + nafter, :]
 
-            waveform_accumulator_per_worker[worker_index, unit_index, :, :] += wf
-            if waveform_squared_accumulator_per_worker is not None:
-                waveform_squared_accumulator_per_worker[worker_index, unit_index, :, :] += wf**2
+            if sparsity_mask is None:
+                waveform_accumulator_per_worker[worker_index, unit_index, :, :] += wf
+                if waveform_squared_accumulator_per_worker is not None:
+                    waveform_squared_accumulator_per_worker[worker_index, unit_index, :, :] += wf**2
+
+            else:
+                mask = sparsity_mask[unit_index, :]
+                wf = wf[:, mask]
+                waveform_accumulator_per_worker[worker_index, unit_index, :, : wf.shape[1]] += wf
+                if waveform_squared_accumulator_per_worker is not None:
+                    waveform_squared_accumulator_per_worker[worker_index, unit_index, :, : wf.shape[1]] += wf**2

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/curation/__init__.py

@@ -16,7 +16,7 @@ from .mergeunitssorting import MergeUnitsSorting, merge_units_sorting
 from .splitunitsorting import SplitUnitSorting, split_unit_sorting
 
 # curation format
-from .curation_format import validate_curation_dict, curation_label_to_dataframe, apply_curation
+from .curation_format import validate_curation_dict, curation_label_to_dataframe, apply_curation, load_curation
 
 from .sortingview_curation import apply_sortingview_curation
 

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/curation/auto_merge.py

@@ -74,7 +74,7 @@ _default_step_params = {
         "sigma_smooth_ms": 0.6,
         "adaptative_window_thresh": 0.5,
     },
-    "template_similarity": {"template_diff_thresh": 0.25},
+    "template_similarity": {"similarity_method": "l1", "template_diff_thresh": 0.25},
     "presence_distance": {"presence_distance_thresh": 100},
     "knn": {"k_nn": 10},
     "cross_contamination": {
@@ -310,7 +310,13 @@ def compute_merge_unit_groups(
         # STEP : check if potential merge with CC also have template similarity
         elif step == "template_similarity":
             template_similarity_ext = sorting_analyzer.get_extension("template_similarity")
-            templates_similarity = template_similarity_ext.get_data()
+            if template_similarity_ext.params["method"] == params["similarity_method"]:
+                templates_similarity = template_similarity_ext.get_data()
+            else:
+                template_similarity_ext = sorting_analyzer.compute(
+                    "template_similarity", method=params["similarity_method"], save=False
+                )
+                templates_similarity = template_similarity_ext.get_data()
             templates_diff = 1 - templates_similarity
             pair_mask = pair_mask & (templates_diff < params["template_diff_thresh"])
             outs["templates_diff"] = templates_diff
@@ -1057,17 +1063,29 @@ def compute_cross_contaminations(analyzer, pair_mask, cc_thresh, refractory_peri
     CC = np.zeros((n, n), dtype=np.float32)
     p_values = np.zeros((n, n), dtype=np.float32)
 
-    for unit_ind1 in range(len(unit_ids)):
+    if sorting.get_num_segments() > 1:
+        # for multi-segment sortings, we need to concatenate segments,
+        from spikeinterface import concatenate_sortings, select_segment_sorting
+
+        sorting_list = []
+        total_samples_list = []
+        for segment_index in range(sorting.get_num_segments()):
+            sorting_list.append(select_segment_sorting(sorting, segment_index))
+            total_samples_list.append(analyzer.get_num_samples(segment_index))
+        # concatenate segments
+        sorting_concat = concatenate_sortings(sorting_list=sorting_list, total_samples_list=total_samples_list)
+    else:
+        sorting_concat = sorting
 
+    for unit_ind1 in range(len(unit_ids)):
         unit_id1 = unit_ids[unit_ind1]
-        spike_train1 = np.array(sorting.get_unit_spike_train(unit_id1))
-
+        spike_train1 = np.array(sorting_concat.get_unit_spike_train(unit_id1))
         for unit_ind2 in range(unit_ind1 + 1, len(unit_ids)):
             if not pair_mask[unit_ind1, unit_ind2]:
                 continue
 
             unit_id2 = unit_ids[unit_ind2]
-            spike_train2 = np.array(sorting.get_unit_spike_train(unit_id2))
+            spike_train2 = np.array(sorting_concat.get_unit_spike_train(unit_id2))
             # Compuyting the cross-contamination difference
             if contaminations is not None:
                 C1 = contaminations[unit_ind1]
@@ -1194,8 +1212,8 @@ def presence_distance(sorting, unit1, unit2, bin_duration_s=2, bins=None, num_sa
                 ns = num_samples[segment_index]
             bins = np.arange(0, ns, bin_size)
 
-        st1 = sorting.get_unit_spike_train(unit_id=unit1)
-        st2 = sorting.get_unit_spike_train(unit_id=unit2)
+        st1 = sorting.get_unit_spike_train(unit_id=unit1, segment_index=segment_index)
+        st2 = sorting.get_unit_spike_train(unit_id=unit2, segment_index=segment_index)
 
         h1, _ = np.histogram(st1, bins)
         h1 = h1.astype(float)

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/curation/curation_format.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from pathlib import Path
+import json
 import numpy as np
 from itertools import chain
 
@@ -141,6 +143,7 @@ def apply_curation(
     new_id_strategy: str = "append",
     merging_mode: str = "soft",
     sparsity_overlap: float = 0.75,
+    raise_error_if_overlap_fails: bool = True,
     verbose: bool = False,
     **job_kwargs,
 ):
@@ -179,6 +182,9 @@ def apply_curation(
     sparsity_overlap : float, default 0.75
         The percentage of overlap that units should share in order to accept merges. If this criteria is not
         achieved, soft merging will not be possible and an error will be raised. This is for use with a SortingAnalyzer input.
+    raise_error_if_overlap_fails : bool, default: True
+        If True and `sparsity_overlap` fails for any unit merges, this will raise an error. If False, units which fail the
+        `sparsity_overlap` threshold will be skipped in the merge.
     verbose : bool, default: False
         If True, output is verbose
     **job_kwargs : dict
@@ -232,6 +238,7 @@ def apply_curation(
                 censor_ms=censor_ms,
                 merging_mode=merging_mode,
                 sparsity_overlap=sparsity_overlap,
+                raise_error_if_overlap_fails=raise_error_if_overlap_fails,
                 new_id_strategy=new_id_strategy,
                 return_new_unit_ids=True,
                 format="memory",
@@ -271,3 +278,22 @@ def apply_curation(
             )
 
     return curated_sorting_or_analyzer
+
+
+def load_curation(curation_path: str | Path) -> CurationModel:
+    """
+    Loads a curation from a local json file.
+
+    Parameters
+    ----------
+    curation_path : str or Path
+        The path to the curation json file
+
+    Returns
+    -------
+    curation_model : CurationModel
+        A CurationModel object
+    """
+    with open(curation_path) as f:
+        curation_dict = json.load(f)
+    return CurationModel(**curation_dict)

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/curation/model_based_curation.py

@@ -188,14 +188,9 @@ class ModelBasedClassification:
                     else:
                         warnings.warn(warning_message)
 
-    def _export_to_phy(self, classified_units):
+    def _export_to_phy(self, classified_df):
         """Export the classified units to Phy as cluster_prediction.tsv file"""
 
-        import pandas as pd
-
-        # Create a new DataFrame with unit_id, prediction, and probability columns from dict {unit_id: (prediction, probability)}
-        classified_df = pd.DataFrame.from_dict(classified_units, orient="index", columns=["prediction", "probability"])
-
         # Export to Phy format
         try:
             sorting_path = self.sorting_analyzer.sorting.get_annotation("phy_folder")

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/extractors/neoextractors/neobaseextractor.py

@@ -665,14 +665,20 @@ _neo_event_dtype = np.dtype([("time", "float64"), ("duration", "float64"), ("lab
 class NeoBaseEventExtractor(_NeoBaseExtractor, BaseEvent):
     handle_event_frame_directly = False
 
-    def __init__(self, block_index=None, **neo_kwargs):
+    def __init__(self, block_index=None, use_names_as_ids: bool = False, **neo_kwargs):
         _NeoBaseExtractor.__init__(self, block_index, **neo_kwargs)
 
         # TODO load feature from neo array_annotations
 
         event_channels = self.neo_reader.header["event_channels"]
 
-        channel_ids = event_channels["id"]
+        if use_names_as_ids:
+            channel_ids = event_channels["name"]
+            assert (
+                event_channels.size == np.unique(channel_ids).size
+            ), "use_name_as_ids=True is not possible, channel names are not unique"
+        else:
+            channel_ids = event_channels["id"]
 
         BaseEvent.__init__(self, channel_ids, structured_dtype=_neo_event_dtype)
 
@@ -684,21 +690,23 @@ class NeoBaseEventExtractor(_NeoBaseExtractor, BaseEvent):
             else:
                 t_start = self.neo_reader.get_signal_t_start(self.block_index, segment_index, stream_index=0)
 
-            event_segment = NeoEventSegment(self.neo_reader, self.block_index, segment_index, t_start)
+            event_segment = NeoEventSegment(self.neo_reader, self.block_index, segment_index, t_start, use_names_as_ids)
             self.add_event_segment(event_segment)
 
 
 class NeoEventSegment(BaseEventSegment):
-    def __init__(self, neo_reader, block_index, segment_index, t_start):
+    def __init__(self, neo_reader, block_index, segment_index, t_start, use_names_as_ids):
         BaseEventSegment.__init__(self)
         self.neo_reader = neo_reader
         self.segment_index = segment_index
         self.block_index = block_index
         self._t_start = t_start
         self._natural_ids = None
+        self.use_names_as_ids = use_names_as_ids
 
     def get_events(self, channel_id, start_time, end_time):
-        channel_index = list(self.neo_reader.header["event_channels"]["id"]).index(channel_id)
+        id_or_name = "name" if self.use_names_as_ids else "id"
+        channel_index = list(self.neo_reader.header["event_channels"][id_or_name]).index(channel_id)
 
         event_timestamps, event_duration, event_labels = self.neo_reader.get_event_timestamps(
             block_index=self.block_index, seg_index=self.segment_index, event_channel_index=channel_index

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/extractors/neoextractors/plexon2.py

@@ -118,14 +118,20 @@ class Plexon2EventExtractor(NeoBaseEventExtractor):
     Parameters
     ----------
     folder_path : str
+        Path to the .pl2 file.
+    block_index : int, default: None
+        Block index to read from, by default None.
+    use_names_as_ids : bool, default: False
+        If True, use channel names as identifiers instead of channel IDs.
+        Channel names must be unique when this option is enabled.
 
     """
 
     NeoRawIOClass = "Plexon2RawIO"
 
-    def __init__(self, folder_path, block_index=None):
+    def __init__(self, folder_path, block_index=None, use_names_as_ids=False):
         neo_kwargs = self.map_to_neo_kwargs(folder_path)
-        NeoBaseEventExtractor.__init__(self, block_index=block_index, **neo_kwargs)
+        NeoBaseEventExtractor.__init__(self, block_index=block_index, use_names_as_ids=use_names_as_ids, **neo_kwargs)
 
     @classmethod
     def map_to_neo_kwargs(cls, folder_path):

{spikeinterface-0.103.1 → spikeinterface-0.103.2}/src/spikeinterface/generation/drift_tools.py

@@ -7,6 +7,8 @@ import numpy as np
 from numpy.typing import ArrayLike
 from spikeinterface.core import BaseRecording, BaseRecordingSegment, BaseSorting, Templates
 
+from probeinterface import Probe
+
 
 def interpolate_templates(templates_array, source_locations, dest_locations, interpolation_method="cubic"):
     """