Merge branch 'main' into parralel_with_thread

Author: alejoe91

doc/how_to/benchmark_with_hybrid_recordings.rst

@@ -2531,9 +2531,8 @@ Although non of the sorters find all units perfectly, ``Kilosort2.5``,
 ``Kilosort4``, and ``SpyKING CIRCUS 2`` all find around 10-12 hybrid
 units with accuracy greater than 80%. ``Kilosort4`` has a better overall
 curve, being able to find almost all units with an accuracy above 50%.
-``Kilosort2.5`` performs well when looking at precision (finding all
-spikes in a hybrid unit), at the cost of lower recall (finding spikes
-when it shouldn’t).
+``Kilosort2.5`` performs well when looking at precision (not finding spikes
+when it shouldn’t), but it has a lower recall (finding all spikes in the ground truth).
 
 In this example, we showed how to:
 

examples/how_to/benchmark_with_hybrid_recordings.py

@@ -276,7 +276,8 @@
 # From the performance plots, we can see that there is no clear "winner", but `Kilosort3` definitely performs worse than the other options.
 #
 # Although non of the sorters find all units perfectly, `Kilosort2.5`, `Kilosort4`, and `SpyKING CIRCUS 2` all find around 10-12 hybrid units with accuracy greater than 80%.
-# `Kilosort4` has a better overall curve, being able to find almost all units with an accuracy above 50%. `Kilosort2.5` performs well when looking at precision (finding all spikes in a hybrid unit), at the cost of lower recall (finding spikes when it shouldn't).
+# `Kilosort4` has a better overall curve, being able to find almost all units with an accuracy above 50%. `Kilosort2.5` performs well when looking at precision (not finding spikes
+# when it shouldn’t), but it has a lower recall (finding all spikes in the ground truth).
 #
 #
 # In this example, we showed how to:

src/spikeinterface/core/baserecording.py

@@ -232,15 +232,9 @@ def get_duration(self, segment_index=None) -> float:
         float
             The duration in seconds
         """
-        segment_index = self._check_segment_index(segment_index)
-
-        if self.has_time_vector(segment_index):
-            times = self.get_times(segment_index)
-            segment_duration = times[-1] - times[0] + (1 / self.get_sampling_frequency())
-        else:
-            segment_num_samples = self.get_num_samples(segment_index=segment_index)
-            segment_duration = segment_num_samples / self.get_sampling_frequency()
-
+        segment_duration = (
+            self.get_end_time(segment_index) - self.get_start_time(segment_index) + (1 / self.get_sampling_frequency())
+        )
         return segment_duration
 
     def get_total_duration(self) -> float:
@@ -252,7 +246,7 @@ def get_total_duration(self) -> float:
         float
             The duration in seconds
         """
-        duration = sum([self.get_duration(idx) for idx in range(self.get_num_segments())])
+        duration = sum([self.get_duration(segment_index) for segment_index in range(self.get_num_segments())])
         return duration
 
     def get_memory_size(self, segment_index=None) -> int:
@@ -445,6 +439,40 @@ def get_times(self, segment_index=None) -> np.ndarray:
         times = rs.get_times()
         return times
 
+    def get_start_time(self, segment_index=None) -> float:
+        """Get the start time of the recording segment.
+
+        Parameters
+        ----------
+        segment_index : int or None, default: None
+            The segment index (required for multi-segment)
+
+        Returns
+        -------
+        float
+            The start time in seconds
+        """
+        segment_index = self._check_segment_index(segment_index)
+        rs = self._recording_segments[segment_index]
+        return rs.get_start_time()
+
+    def get_end_time(self, segment_index=None) -> float:
+        """Get the stop time of the recording segment.
+
+        Parameters
+        ----------
+        segment_index : int or None, default: None
+            The segment index (required for multi-segment)
+
+        Returns
+        -------
+        float
+            The stop time in seconds
+        """
+        segment_index = self._check_segment_index(segment_index)
+        rs = self._recording_segments[segment_index]
+        return rs.get_end_time()
+
     def has_time_vector(self, segment_index=None):
         """Check if the segment of the recording has a time vector.
 
@@ -903,6 +931,21 @@ def get_times(self) -> np.ndarray:
                 time_vector += self.t_start
             return time_vector
 
+    def get_start_time(self) -> float:
+        if self.time_vector is not None:
+            return self.time_vector[0]
+        else:
+            return self.t_start if self.t_start is not None else 0.0
+
+    def get_end_time(self) -> float:
+        if self.time_vector is not None:
+            return self.time_vector[-1]
+        else:
+            t_stop = (self.get_num_samples() - 1) / self.sampling_frequency
+            if self.t_start is not None:
+                t_stop += self.t_start
+            return t_stop
+
     def get_times_kwargs(self) -> dict:
         """
         Retrieves the timing attributes characterizing a RecordingSegment

src/spikeinterface/core/loading.py

@@ -104,7 +104,7 @@ def load(file_or_folder_or_dict, base_folder=None) -> BaseExtractor:
                 raise ValueError(error_msg)
         else:
             # remote case - zarr
-            if str(file_path).endswith(".zarr"):
+            if str(file_path).endswith(".zarr") or str(file_path).endswith(".zarr/"):
                 from .zarrextractors import read_zarr
 
                 extractor = read_zarr(file_path)

src/spikeinterface/preprocessing/average_across_direction.py

@@ -132,7 +132,10 @@ def get_traces(self, start_frame, end_frame, channel_indices):
         # now, divide by the number of channels at that position
         traces /= self.n_chans_each_pos
 
-        return traces[:, channel_indices]
+        if channel_indices is not None:
+            traces = traces[:, channel_indices]
+
+        return traces
 
 
 # function for API