Merge branch 'main' into zarr-dep

Author: h-mayorquin

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/extractors/neuropixels_utils.py

@@ -1,39 +1,47 @@
 from __future__ import annotations
 
 import numpy as np
+from typing import Optional
 
 
-def get_neuropixels_sample_shifts(num_channels=384, num_channels_per_adc=12, num_cycles=None):
+def get_neuropixels_sample_shifts(
+    num_channels: int = 384, num_channels_per_adc: int = 12, num_cycles: Optional[int] = None
+) -> np.ndarray:
     """
-    Calculates the relative sampling phase of each channel that results
-    from Neuropixels ADC multiplexing.
+    Calculate the relative sampling phase (inter-sample shifts) for each channel
+    in Neuropixels probes due to ADC multiplexing.
 
-    This information is needed to perform the preprocessing.phase_shift operation.
+    Neuropixels probes sample channels sequentially through multiple ADCs,
+    introducing slight temporal delays between channels within each sampling cycle.
+    These inter-sample shifts are fractions of the sampling period and are crucial
+    to consider during preprocessing steps, such as phase correction, to ensure
+    accurate alignment of the recorded signals.
 
-    See https://github.com/int-brain-lab/ibllib/blob/master/ibllib/ephys/neuropixel.py
-
-
-    for the original implementation.
+    This function computes these relative phase shifts, returning an array where
+    each value represents the fractional delay (ranging from 0 to 1) for the
+    corresponding channel.
 
     Parameters
     ----------
     num_channels : int, default: 384
-        The total number of channels in a recording.
-        All currently available Neuropixels variants have 384 channels.
+        Total number of channels in the recording.
+        Neuropixels probes typically have 384 channels.
     num_channels_per_adc : int, default: 12
-        The number of channels per ADC on the probe.
-        Neuropixels 1.0 probes have 12 ADCs.
+        Number of channels assigned to each ADC on the probe.
+        Neuropixels 1.0 probes have 12 ADCs, each handling 32 channels.
         Neuropixels 2.0 probes have 16 ADCs.
-    num_cycles: int or None, default: None
-        The number of cycles in the ADC on the probe.
-        Neuropixels 1.0 probes have 13 cycles for AP and 12 for LFP.
+    num_cycles : int or None, default: None
+        Number of cycles in the ADC sampling sequence.
+        Neuropixels 1.0 probes have 13 cycles for AP (action potential) signals
+        and 12 for LFP (local field potential) signals.
         Neuropixels 2.0 probes have 16 cycles.
-        If None, the num_channels_per_adc is used.
+        If None, defaults to the value of `num_channels_per_adc`.
 
     Returns
     -------
-    sample_shifts : ndarray
-        The relative phase (from 0-1) of each channel
+    sample_shifts : np.ndarray
+        Array of relative phase shifts for each channel, with values ranging from 0 to 1,
+        representing the fractional delay within the sampling period due to sequential ADC sampling.
     """
     if num_cycles is None:
         num_cycles = num_channels_per_adc
@@ -44,9 +52,8 @@ def get_neuropixels_sample_shifts(num_channels=384, num_channels_per_adc=12, num
 
     sample_shifts = np.zeros_like(adc_indices)
 
-    for a in adc_indices:
-        sample_shifts[adc_indices == a] = np.arange(num_channels_per_adc) / num_cycles
-
+    for adc_index in adc_indices:
+        sample_shifts[adc_indices == adc_index] = np.arange(num_channels_per_adc) / num_cycles
     return sample_shifts
 
 

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