Merge branch 'NeuralEnsemble:master' into enh/array_anno_types

Author: JuliaSprenger

.github/workflows/caches_cron_job.yml

@@ -60,8 +60,7 @@ jobs:
           git config --global user.email "neo_ci@fake_mail.com"
           git config --global user.name "neo CI"
           python -m pip install -U pip  # Official recommended way
-          pip install --upgrade -e .
-          pip install .[test]
+          pip install --upgrade -e .[test]
 
   create-data-cache-if-missing:
     name: Caching data env

doc/source/share_data.rst

@@ -213,4 +213,4 @@ Now that we have annotated our dataset, we can write it to an NWB file:
 .. _`Whole cell patch-clamp recordings of cerebellar granule cells`: https://doi.org/10.25493/CHJG-7QC
 .. _EBRAINS: https://ebrains.eu/services/data-and-knowledge/
 .. _`NIX data model`: https://nixpy.readthedocs.io/
-.. _`FAIR guiding principles`: https://doi.org/10.1038/sdata.2016.18`
+.. _`FAIR guiding principles`: https://doi.org/10.1038/sdata.2016.18

neo/io/asciisignalio.py

@@ -39,7 +39,7 @@ class AsciiSignalIO(BaseIO):
             column delimiter in file, e.g. '\t', one space, two spaces, ',', ';'
         timecolumn:
             None or a valid integer that identifies which column contains the time vector
-            (counting from zero)
+            (counting from zero, within the list of selected columns, see also `usecols` argument)
         units:
             units of AnalogSignal can be a str or directly a Quantity
         time_units:
@@ -251,13 +251,16 @@ def read_segment(self, lazy=False):
             t_start = sig[0, self.timecolumn] * self.time_units
 
         if self.signal_group_mode == 'all-in-one':
+            channel_index_annotation = self.usecols or np.arange(sig.shape[1])
+            channel_index_annotation = np.asarray(channel_index_annotation)
             if self.timecolumn is not None:
                 mask = list(range(sig.shape[1]))
                 if self.timecolumn >= 0:
                     mask.remove(self.timecolumn)
                 else:  # allow negative column index
                     mask.remove(sig.shape[1] + self.timecolumn)
                 signal = sig[:, mask]
+                channel_index_annotation = channel_index_annotation[mask]
             else:
                 signal = sig
             if sampling_rate is None:
@@ -269,7 +272,7 @@ def read_segment(self, lazy=False):
                 ana_sig = AnalogSignal(signal * self.units, sampling_rate=sampling_rate,
                                        t_start=t_start,
                                        name='multichannel')
-                ana_sig.array_annotate(channel_index=self.usecols or np.arange(signal.shape[1]))
+                ana_sig.array_annotate(channel_index=channel_index_annotation)
                 seg.analogsignals.append(ana_sig)
         else:
             if self.timecolumn is not None and self.timecolumn < 0:

neo/rawio/alphaomegarawio.py

@@ -4,9 +4,9 @@
 This module expect default channel names from the AlphaOmega record system (RAW
 ###, SPK ###, LFP ###, AI ###,…).
 
-This module reads all \*.mpx files in a directory (not recursively) by default.
-If you provide a list of \*.lsx files only the \*.mpx files referenced by those
-\*.lsx files will be loaded.
+This module reads all *.mpx files in a directory (not recursively) by default.
+If you provide a list of *.lsx files only the *.mpx files referenced by those
+*.lsx files will be loaded.
 
 The specifications are mostly extracted from the "AlphaRS User Manual V1.0.1.pdf"
 manual provided with the AlphaRS hardware. The specifications are described in

neo/rawio/examplerawio.py

@@ -58,7 +58,7 @@ class ExampleRawIO(BaseRawIO):
     This fake IO:
         * has 2 blocks
         * blocks have 2 and 3 segments
-        * has  2 signals streams  of 8 channel each (sample_rate = 10000) so 16 channels in total
+        * has  2 signals streams  of 8 channels each (sample_rate = 10000) so 16 channels in total
         * has 3 spike_channels
         * has 2 event channels: one has *type=event*, the other has
           *type=epoch*
@@ -100,17 +100,17 @@ def _parse_header(self):
         # information required for fast access
         # at any place in the file
         # In short `_parse_header()` can be slow but
-        # `_get_analogsignal_chunk()` need to be as fast as possible
+        # `_get_analogsignal_chunk()` needs to be as fast as possible
 
-        # create fake signals stream information
+        # create fake signal streams information
         signal_streams = []
         for c in range(2):
             name = f'stream {c}'
             stream_id = c
             signal_streams.append((name, stream_id))
         signal_streams = np.array(signal_streams, dtype=_signal_stream_dtype)
 
-        # create fake signals channels information
+        # create fake signal channels information
         # This is mandatory!!!!
         # gain/offset/units are really important because
         # the scaling to real value will be done with that
@@ -121,15 +121,15 @@ def _parse_header(self):
             # our channel id is c+1 just for fun
             # Note that chan_id should be related to
             # original channel id in the file format
-            # so that the end user should not be lost when reading datasets
+            # so that the end user should not be confused when reading datasets
             chan_id = c + 1
             sr = 10000.  # Hz
             dtype = 'int16'
             units = 'uV'
             gain = 1000. / 2 ** 16
             offset = 0.
             # stream_id indicates how to group channels
-            # channels inside a "stream" share same characteristics
+            # channels inside a "stream" share the same characteristics
             #  (sampling rate/dtype/t_start/units/...)
             stream_id = str(c // 8)
             signal_channels.append((ch_name, chan_id, sr, dtype, units, gain, offset, stream_id))
@@ -142,7 +142,7 @@ def _parse_header(self):
         # will be generated per Segment.
         signal_channels[-2:]['units'] = 'pA'
 
-        # create fake units channels
+        # create fake unit channels
         # This is mandatory!!!!
         # Note that if there is no waveform at all in the file
         # then wf_units/wf_gain/wf_offset/wf_left_sweep/wf_sampling_rate
@@ -163,13 +163,13 @@ def _parse_header(self):
 
         # creating event/epoch channel
         # This is mandatory!!!!
-        # In RawIO epoch and event they are dealt the same way.
+        # In RawIO epoch and event are dealt with in the same way.
         event_channels = []
         event_channels.append(('Some events', 'ev_0', 'event'))
         event_channels.append(('Some epochs', 'ep_1', 'epoch'))
         event_channels = np.array(event_channels, dtype=_event_channel_dtype)
 
-        # fille into header dict
+        # fill information into the header dict
         # This is mandatory!!!!!
         self.header = {}
         self.header['nb_block'] = 2
@@ -187,7 +187,7 @@ def _parse_header(self):
         # `_generate_minimal_annotations()` must be called to generate the nested
         # dict of annotations/array_annotations
         self._generate_minimal_annotations()
-        # this pprint lines really help for understand the nested (and complicated sometimes) dict
+        # this pprint lines really help with understanding the nested (and sometimes complicated) dict
         # from pprint import pprint
         # pprint(self.raw_annotations)
 
@@ -229,14 +229,14 @@ def _parse_header(self):
                         event_an['nickname'] = 'MrEpoch 1'
 
     def _segment_t_start(self, block_index, seg_index):
-        # this must return an float scale in second
-        # this t_start will be shared by all object in the segment
+        # this must return a float scaled in seconds
+        # this t_start will be shared by all objects in the segment
         # except AnalogSignal
         all_starts = [[0., 15.], [0., 20., 60.]]
         return all_starts[block_index][seg_index]
 
     def _segment_t_stop(self, block_index, seg_index):
-        # this must return an float scale in second
+        # this must return a float scaled in seconds
         all_stops = [[10., 25.], [10., 30., 70.]]
         return all_stops[block_index][seg_index]
 
@@ -245,20 +245,20 @@ def _get_signal_size(self, block_index, seg_index, stream_index):
         # across all segments (10.0 seconds)
         # This is not the case for real data, instead you should return the signal
         # size depending on the block_index and segment_index
-        # this must return an int = the number of sample
+        # this must return an int = the number of samples
 
         # Note that channel_indexes can be ignored for most cases
-        # except for several sampling rate.
+        # except for the case of several sampling rates.
         return 100000
 
     def _get_signal_t_start(self, block_index, seg_index, stream_index):
-        # This give the t_start of signals.
-        # Very often this equal to _segment_t_start but not
+        # This give the t_start of a signal.
+        # Very often this is equal to _segment_t_start but not
         # always.
-        # this must return an float scale in second
+        # this must return a float scaled in seconds
 
         # Note that channel_indexes can be ignored for most cases
-        # except for several sampling rate.
+        # except for the case of several sampling rates.
 
         # Here this is the same.
         # this is not always the case
@@ -271,11 +271,11 @@ def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop,
         # channel_indexes can be None (=all channel in the stream) or a list or numpy.array
         # This must return a numpy array 2D (even with one channel).
         # This must return the original dtype. No conversion here.
-        # This must as fast as possible.
+        # This must be as fast as possible.
         # To speed up this call all preparatory calculations should be implemented
         # in _parse_header().
 
-        # Here we are lucky:  our signals is always zeros!!
+        # Here we are lucky:  our signals are always zeros!!
         # it is not always the case :)
         # internally signals are int16
         # conversion to real units is done with self.header['signal_channels']
@@ -286,7 +286,7 @@ def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop,
             i_stop = 100000
 
         if i_start < 0 or i_stop > 100000:
-            # some check
+            # some checks
             raise IndexError("I don't like your jokes")
 
         if channel_indexes is None:
@@ -334,8 +334,8 @@ def _get_spike_timestamps(self, block_index, seg_index, spike_channel_index, t_s
         return spike_timestamps
 
     def _rescale_spike_timestamp(self, spike_timestamps, dtype):
-        # must rescale to second a particular spike_timestamps
-        # with a fixed dtype so the user can choose the precision he want.
+        # must rescale to seconds, a particular spike_timestamps
+        # with a fixed dtype so the user can choose the precision they want.
         spike_times = spike_timestamps.astype(dtype)
         spike_times /= 10000.  # because 10kHz
         return spike_times
@@ -355,7 +355,7 @@ def _get_spike_raw_waveforms(self, block_index, seg_index, spike_channel_index,
         # conversion to real units is done with self.header['spike_channels']
         # Here, we have a realistic case: all waveforms are only noise.
         # it is not always the case
-        # we 20 spikes with a sweep of 50 (5ms)
+        # we get 20 spikes with a sweep of 50 (5ms)
 
         # trick to get how many spike in the slice
         ts = self._get_spike_timestamps(block_index, seg_index,
@@ -379,11 +379,11 @@ def _event_count(self, block_index, seg_index, event_channel_index):
 
     def _get_event_timestamps(self, block_index, seg_index, event_channel_index, t_start, t_stop):
         # the main difference between spike channel and event channel
-        # is that for here we have 3 numpy array timestamp, durations, labels
+        # is that for event channels we have 3D numpy array (timestamp, durations, labels) where
         # durations must be None for 'event'
         # label must a dtype ='U'
 
-        # in our IO event are directly coded in seconds
+        # in our IO events are directly coded in seconds
         seg_t_start = self._segment_t_start(block_index, seg_index)
         if event_channel_index == 0:
             timestamp = np.arange(0, 6, dtype='float64') + seg_t_start
@@ -409,14 +409,14 @@ def _get_event_timestamps(self, block_index, seg_index, event_channel_index, t_s
         return timestamp, durations, labels
 
     def _rescale_event_timestamp(self, event_timestamps, dtype, event_channel_index):
-        # must rescale to second a particular event_timestamps
-        # with a fixed dtype so the user can choose the precision he want.
+        # must rescale to seconds for a particular event_timestamps
+        # with a fixed dtype so the user can choose the precision they want.
 
-        # really easy here because in our case it is already seconds
+        # really easy here because in our case it is already in seconds
         event_times = event_timestamps.astype(dtype)
         return event_times
 
     def _rescale_epoch_duration(self, raw_duration, dtype, event_channel_index):
-        # really easy here because in our case it is already seconds
+        # really easy here because in our case it is already in seconds
         durations = raw_duration.astype(dtype)
         return durations

neo/test/iotest/test_asciisignalio.py

@@ -61,7 +61,9 @@ def test_csv_expect_success(self):
             for row in sample_data:
                 writer.writerow(row)
 
-        io = AsciiSignalIO(filename, usecols=(0, 1, 3), timecolumn=2,
+        usecols = (0, 1, 3)
+        timecolumn = 2
+        io = AsciiSignalIO(filename, usecols=usecols, timecolumn=timecolumn,
                            # note that timecolumn applies to the remaining columns
                            # after applying usecols
                            time_units="ms", delimiter=',', units="mV", method='csv',
@@ -76,6 +78,11 @@ def test_csv_expect_success(self):
                                   decimal=5)
         self.assertAlmostEqual(signal.sampling_period, 0.1 * pq.ms)
 
+        expected_channel_index = list(usecols)
+        # remove time column as it is not loaded as signal channel
+        expected_channel_index.pop(timecolumn)
+        assert_array_equal(expected_channel_index, signal.array_annotations['channel_index'])
+
         os.remove(filename)
     # test_csv_expect_failure
 

neo/test/iotest/test_nixio.py

@@ -138,7 +138,7 @@ def compare_signal_dalist(self, neosig, nixdalist):
                 neosp = neosig.sampling_period
                 nixsp = create_quantity(timedim.sampling_interval,
                                         timedim.unit)
-                self.assertEqual(neosp, nixsp)
+                self.assertAlmostEqual(neosp, nixsp)
                 tsunit = timedim.unit
                 if "t_start.units" in da.metadata.props:
                     tsunit = da.metadata["t_start.units"]