Merge branch 'main' into metric_system_units_docs

Author: h-mayorquin

doc/how_to/combine_recordings.rst

@@ -4,7 +4,7 @@ Combine recordings in SpikeInterface
 In this tutorial we will walk through combining multiple recording objects. Sometimes this occurs due to hardware
 settings (e.g. Intan software has a default setting of new files every 1 minute) or the experimenter decides to
 split their recording into multiple files for different experimental conditions. If the probe has not been moved,
-however, then during sorting it would likely make sense to combine these individual reocrding objects into one
+however, then during sorting it would likely make sense to combine these individual recording objects into one
 recording object.
 
 **Why Combine?**

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spikeinterface"
-version = "0.102.3"
+version = "0.102.4"
 authors = [
   { name="Alessio Buccino", email="alessiop.buccino@gmail.com" },
   { name="Samuel Garcia", email="sam.garcia.die@gmail.com" },
@@ -126,17 +126,17 @@ test_core = [
 
     # 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",
-    # "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
+    "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",
+    "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
 ]
 
 test_extractors = [
     # Functions to download data in neo test suite
     "pooch>=1.8.2",
     "datalad>=1.0.2",
     # Commenting out for release
-    # "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",
-    # "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
+    "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",
+    "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
 ]
 
 test_preprocessing = [
@@ -174,8 +174,8 @@ test = [
 
     # 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",
-    # "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
+    "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",
+    "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",
 ]
 
 docs = [
@@ -200,8 +200,8 @@ docs = [
     "datalad>=1.0.2",
 
     # for release we need pypi, so this needs to be commented
-    # "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",  # We always build from the latest version
-    # "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",  # We always build from the latest version
+    "probeinterface @ git+https://github.com/SpikeInterface/probeinterface.git",  # We always build from the latest version
+    "neo @ git+https://github.com/NeuralEnsemble/python-neo.git",  # We always build from the latest version
 ]
 
 dev = [

src/spikeinterface/__init__.py

@@ -27,5 +27,5 @@
 # This flag must be set to False for release
 # This avoids using versioning that contains ".dev0" (and this is a better choice)
 # This is mainly useful when using run_sorter in a container and spikeinterface install
-# DEV_MODE = True
-DEV_MODE = False
+DEV_MODE = True
+# DEV_MODE = False

src/spikeinterface/benchmark/benchmark_base.py

@@ -594,15 +594,22 @@ def load_folder(cls, folder):
             elif format == "sorting":
                 from spikeinterface.core import load_extractor
 
-                result[k] = load(folder / k)
+                sorting_folder = folder / k
+                if sorting_folder.exists():
+                    result[k] = load(sorting_folder)
             elif format == "Motion":
                 from spikeinterface.core.motion import Motion
 
-                result[k] = Motion.load(folder / k)
+                motion_folder = folder / k
+                if motion_folder.exists():
+                    result[k] = Motion.load(motion_folder)
             elif format == "zarr_templates":
                 from spikeinterface.core.template import Templates
 
-                result[k] = Templates.from_zarr(folder / k)
+                zarr_folder = folder / k
+                if zarr_folder.exists():
+
+                    result[k] = Templates.from_zarr(zarr_folder)
 
         return result
 

src/spikeinterface/core/baserecording.py

@@ -757,9 +757,9 @@ def frame_slice(self, start_frame: int | None, end_frame: int | None) -> BaseRec
         Parameters
         ----------
         start_frame : int, optional
-            The start frame, if not provided it is set to 0
+            Start frame index. If None, defaults to the beginning of the recording (frame 0).
         end_frame : int, optional
-            The end frame, it not provided it is set to the total number of samples
+            End frame index. If None, defaults to the last frame of the recording.
 
         Returns
         -------
@@ -779,9 +779,9 @@ def time_slice(self, start_time: float | None, end_time: float | None) -> BaseRe
         Parameters
         ----------
         start_time : float, optional
-            The start time in seconds. If not provided it is set to 0.
+            Start time in seconds. If None, defaults to the beginning of the recording.
         end_time : float, optional
-            The end time in seconds. If not provided it is set to the total duration.
+            End time in seconds. If None, defaults to the end of the recording.
 
         Returns
         -------

src/spikeinterface/extractors/nwbextractors.py

@@ -759,10 +759,13 @@ def _fetch_recording_segment_info_backend(self, file, cache, load_time_vector, s
         if "starting_time" in electrical_series.keys():
             t_start = electrical_series["starting_time"][()]
             sampling_frequency = electrical_series["starting_time"].attrs["rate"]
+            timestamps = None
         elif "timestamps" in electrical_series.keys():
             timestamps = electrical_series["timestamps"][:]
             t_start = timestamps[0]
             sampling_frequency = 1.0 / np.median(np.diff(timestamps[:samples_for_rate_estimation]))
+        else:
+            raise ValueError("TimeSeries must have either starting_time or timestamps")
 
         if load_time_vector and timestamps is not None:
             times_kwargs = dict(time_vector=electrical_series["timestamps"])
@@ -1572,6 +1575,8 @@ def _fetch_recording_segment_info(self, file, cache, load_time_vector, samples_f
             timestamps = timeseries.timestamps
             sampling_frequency = 1.0 / np.median(np.diff(timestamps[:samples_for_rate_estimation]))
             t_start = timestamps[0]
+        else:
+            raise ValueError("TimeSeries must have either starting_time or timestamps")
 
         if load_time_vector and timestamps is not None:
             times_kwargs = dict(time_vector=timestamps)

src/spikeinterface/postprocessing/spike_amplitudes.py

@@ -17,38 +17,19 @@ class ComputeSpikeAmplitudes(AnalyzerExtension):
     Computes the spike amplitudes.
 
     Needs "templates" to be computed first.
-    Localize spikes in 2D or 3D with several methods given the template.
+    Computes spike amplitudes from the template's peak channel for every spike.
 
     Parameters
     ----------
     sorting_analyzer : SortingAnalyzer
         A SortingAnalyzer object
-    ms_before : float, default: 0.5
-        The left window, before a peak, in milliseconds
-    ms_after : float, default: 0.5
-        The right window, after a peak, in milliseconds
-    spike_retriver_kwargs : dict
-        A dictionary to control the behavior for getting the maximum channel for each spike
-        This dictionary contains:
-          * channel_from_template: bool, default: True
-              For each spike is the maximum channel computed from template or re estimated at every spikes
-              channel_from_template = True is old behavior but less acurate
-              channel_from_template = False is slower but more accurate
-          * radius_um: float, default: 50
-              In case channel_from_template=False, this is the radius to get the true peak
-          * peak_sign, default: "neg"
-              In case channel_from_template=False, this is the peak sign.
-    method : "center_of_mass" | "monopolar_triangulation" | "grid_convolution", default: "center_of_mass"
-        The localization method to use
-    **method_kwargs : dict, default: {}
-        Kwargs which are passed to the method function. These can be found in the docstrings of `compute_center_of_mass`, `compute_grid_convolution` and `compute_monopolar_triangulation`.
-    outputs : "numpy" | "by_unit", default: "numpy"
-        The output format, either concatenated as numpy array or separated on a per unit basis
+    peak_sign : "neg" | "pos" | "both", default: "neg"
+        Sign of the template to compute extremum channel used to retrieve spike amplitudes.
 
     Returns
     -------
-    spike_locations: np.array
-        All locations for all spikes and all units are concatenated
+    spike_amplitudes: np.array
+        All amplitudes for all spikes and all units are concatenated (along time, like in spike vector)
 
     """
 

src/spikeinterface/preprocessing/motion.py

@@ -443,9 +443,6 @@ def compute_motion(
     t1 = time.perf_counter()
     run_times["estimate_motion"] = t1 - t0
 
-    if recording.get_dtype().kind != "f":
-        recording = recording.astype("float32")
-
     motion_info = dict(
         parameters=parameters,
         run_times=run_times,
@@ -554,6 +551,9 @@ def correct_motion(
         **job_kwargs,
     )
 
+    if recording.get_dtype().kind != "f":
+        recording = recording.astype("float32")
+
     recording_corrected = interpolate_motion(recording, motion, **interpolate_motion_kwargs)
 
     if not output_motion and not output_motion_info:

src/spikeinterface/preprocessing/tests/test_motion.py

@@ -32,6 +32,13 @@ def test_estimate_and_correct_motion(create_cache_folder):
     assert motion_info_loaded["motion"] == motion_info["motion"]
 
 
+def test_estimate_and_correct_motion_int():
+
+    rec = generate_recording(durations=[30.0], num_channels=12).astype(int)
+    rec_corrected = correct_motion(rec, estimate_motion_kwargs={"win_step_um": 50, "win_scale_um": 100})
+    assert rec_corrected.get_dtype().kind == "f"
+
+
 def test_get_motion_parameters_preset():
     from pprint import pprint
 

src/spikeinterface/sorters/runsorter.py

@@ -479,8 +479,10 @@ def run_sorter_container(
             extra_kwargs["container_requires_gpu"] = True
 
             if platform.system() == "Linux" and not has_docker_nvidia_installed():
+                from .utils import get_nvidia_docker_dependencies
+
                 warn(
-                    f"nvidia-required but none of \n{get_nvidia_docker_dependecies()}\n were found. "
+                    f"nvidia-required but none of \n{get_nvidia_docker_dependencies()}\n were found. "
                     f"This may result in an error being raised during sorting. Try "
                     "installing `nvidia-container-toolkit`, including setting the "
                     "configuration steps, if running into errors."