Merge branch 'master' into remove-copy

Author: zm711

neo/rawio/brainvisionrawio.py

@@ -92,8 +92,22 @@ def _parse_header(self):
                 channel_desc = channel_infos[f"Ch{c+1}"]
             except KeyError:
                 channel_desc = channel_infos[f"ch{c + 1}"]
-            name, ref, res, units = channel_desc.split(",")
-            units = units.replace("µ", "u")
+            # split up channel description, handling default values
+            cds = channel_desc.split(",")
+            name = cds[0]
+            if len(cds) >= 2:
+                ref = cds[1]
+            else:
+                ref = ""
+            if len(cds) >= 3:
+                res = cds[2]
+            else:
+                res = "1.0"
+            if len(cds) == 4:
+                units = cds[3]
+            else:
+                units = "u"
+            units = units.replace("µ", "u") # Brainvision spec for specific unicode
             chan_id = str(c + 1)
             if sig_dtype == np.int16 or sig_dtype == np.int32:
                 gain = float(res)

neo/rawio/plexon2rawio/plexon2rawio.py

@@ -234,12 +234,12 @@ def _parse_header(self):
 
             # In a PL2 spike channel header, the field "m_NumberOfUnits" denotes the number
             # of units to which spikes detected on that channel have been assigned. It does
-            # not account for unsorted spikes, i.e., spikes that have not been assigned to 
-            # a unit. It is Plexon's convention to assign unsorted spikes to channel_unit_id=0, 
-            # and sorted spikes to channel_unit_id's 1, 2, 3...etc. Therefore, for a given value of 
-            # m_NumberOfUnits, there are m_NumberOfUnits+1 channel_unit_ids to consider - 1 
-            # unsorted channel_unit_id (0) + the m_NumberOfUnits sorted channel_unit_ids. 
-            for channel_unit_id in range(schannel_info.m_NumberOfUnits+1):
+            # not account for unsorted spikes, i.e., spikes that have not been assigned to
+            # a unit. It is Plexon's convention to assign unsorted spikes to channel_unit_id=0,
+            # and sorted spikes to channel_unit_id's 1, 2, 3...etc. Therefore, for a given value of
+            # m_NumberOfUnits, there are m_NumberOfUnits+1 channel_unit_ids to consider - 1
+            # unsorted channel_unit_id (0) + the m_NumberOfUnits sorted channel_unit_ids.
+            for channel_unit_id in range(schannel_info.m_NumberOfUnits + 1):
                 unit_name = f"{schannel_info.m_Name.decode()}.{channel_unit_id}"
                 unit_id = f"unit{schannel_info.m_Channel}.{channel_unit_id}"
                 wf_units = schannel_info.m_Units

neo/rawio/plexonrawio.py

@@ -45,6 +45,7 @@
 
 from neo.core.baseneo import NeoReadWriteError
 
+
 class PlexonRawIO(BaseRawIO):
     extensions = ["plx"]
     rawmode = "one-file"
@@ -232,18 +233,18 @@ def _parse_header(self):
 
         # signals channels
         source_id = []
-        
+
         # Scanning sources and populating signal channels at the same time. Sources have to have
         # same sampling rate and number of samples to belong to one stream.
         signal_channels = []
         channel_num_samples = []
-        
+
         # We will build the stream ids based on the channel prefixes
         # The channel prefixes are the first characters of the channel names which have the following format:
         # WB{number}, FPX{number}, SPKCX{number}, AI{number}, etc
         # We will extract the prefix and use it as stream id
         regex_prefix_pattern = r"^\D+"  # Match any non-digit character at the beginning of the string
-        
+
         if self.progress_bar:
             chan_loop = trange(nb_sig_chan, desc="Parsing signal channels", leave=True)
         else:
@@ -271,7 +272,7 @@ def _parse_header(self):
             offset = 0.0
             channel_prefix = re.match(regex_prefix_pattern, name).group(0)
             stream_id = channel_prefix
-            
+
             signal_channels.append((name, str(chan_id), sampling_rate, sig_dtype, units, gain, offset, stream_id))
 
         signal_channels = np.array(signal_channels, dtype=_signal_channel_dtype)
@@ -312,7 +313,7 @@ def _parse_header(self):
                 self._stream_index_to_stream_id[stream_index] = stream_id
 
                 mask = signal_channels["stream_id"] == stream_id
-                
+
                 signal_num_samples = np.unique(channel_num_samples[mask])
                 if signal_num_samples.size > 1:
                     raise NeoReadWriteError(f"Channels in stream {stream_id} don't have the same number of samples")
@@ -322,7 +323,7 @@ def _parse_header(self):
                 if signal_sampling_frequency.size > 1:
                     raise NeoReadWriteError(f"Channels in stream {stream_id} don't have the same sampling frequency")
                 self._stream_id_sampling_frequency[stream_id] = signal_sampling_frequency[0]
-                
+
         self._global_ssampling_rate = global_header["ADFrequency"]
 
         # Determine number of units per channels
@@ -425,8 +426,6 @@ def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop, strea
         if i_stop is None:
             i_stop = self._stream_id_samples[stream_id]
 
-
-
         mask = signal_channels["stream_id"] == stream_id
         signal_channels = signal_channels[mask]
         if channel_indexes is not None:

neo/test/rawiotest/test_brainvisionrawio.py

@@ -20,6 +20,7 @@ class TestBrainVisionRawIO(
         "brainvision/File_brainvision_3_float32.vhdr",
         "brainvision/File_brainvision_3_int16.vhdr",
         "brainvision/File_brainvision_3_int32.vhdr",
+        "brainvision/File_brainvision_4_float32.vhdr",
     ]
 
     entities_to_download = ["brainvision"]

neo/test/rawiotest/test_neuralynxrawio.py

@@ -361,19 +361,19 @@ def test_equality(self):
         self.assertNotEqual(ns0, ns1)
 
 
-# I comment this now and will put it back when files will be in gin.g-node
-# class TestNlxHeader(TestNeuralynxRawIO, unittest.TestCase):
-#     def test_no_date_time(self):
-#         filename = self.get_local_path("neuralynx/NoDateHeader/NoDateHeader.nev")
+class TestNlxHeader(TestNeuralynxRawIO, unittest.TestCase):
+    def test_no_date_time(self):
+        filename = self.get_local_path("neuralynx/NoDateHeader/NoDateHeader.nev")
 
-#         with self.assertRaises(IOError):
-#             hdr = NlxHeader(filename)
+        with self.assertRaises(IOError):
+            hdr = NlxHeader(filename)
+
+        hdr = NlxHeader(filename, props_only=True)
 
-#         hdr = NlxHeader(filename, props_only=True)
+        self.assertEqual(len(hdr), 11)  # 9 properties plus channel_ids and channel_names
+        self.assertEqual(hdr["ApplicationName"], "Pegasus")
+        self.assertEqual(hdr["FileType"], "Event")
 
-#         self.assertEqual(len(hdr), 11)
-#         self.assertEqual(hdr['ApplicationName'], 'Pegasus')
-#         self.assertEqual(hdr['FileType'], 'Event')
 
 if __name__ == "__main__":
     unittest.main()

neo/test/rawiotest/test_plexon2rawio.py

@@ -26,27 +26,24 @@ class TestPlexon2RawIO(
 ):
     rawioclass = Plexon2RawIO
     entities_to_download = ["plexon"]
-    entities_to_test = ["plexon/4chDemoPL2.pl2",
-                        "plexon/NC16FPSPKEVT_1m.pl2"
-                        ]
-    
+    entities_to_test = ["plexon/4chDemoPL2.pl2", "plexon/NC16FPSPKEVT_1m.pl2"]
 
     def test_check_enabled_flags(self):
         """
         This test loads a 1-minute PL2 file with 16 channels' each
-        of field potential (FP), and spike (SPK) data. The channels 
-        cycle through 4 possible combinations of m_ChannelEnabled 
-        and m_ChannelRecordingEnabled - (True, True), (True, False), 
-        (False, True), and (False, False). With 16 channels for each 
-        source, each combination of flags occurs 4 times. Only the 
+        of field potential (FP), and spike (SPK) data. The channels
+        cycle through 4 possible combinations of m_ChannelEnabled
+        and m_ChannelRecordingEnabled - (True, True), (True, False),
+        (False, True), and (False, False). With 16 channels for each
+        source, each combination of flags occurs 4 times. Only the
         first combination (True, True) causes data to be recorded to
         disk. Therefore, we expect the following channels to be loaded by
         Neo: FP01, FP05, FP09, FP13, SPK01, SPK05, SPK09, and SPK13.
-        
+
         Note: the file contains event (EVT) data as well. Although event
         channel headers do contain m_ChannelEnabled and m_ChannelRecording-
         Enabled flags, the UI for recording PL2 files does not expose any
-        controls by which these flags can be changed from (True, True). 
+        controls by which these flags can be changed from (True, True).
         Therefore, no test for event channels is necessary here.
         """
 
@@ -58,13 +55,14 @@ def test_check_enabled_flags(self):
 
         # Check that the names of the loaded signal channels match what we expect
         signal_channel_names = reader.header["signal_channels"]["name"].tolist()
-        expected_signal_channel_names = ["FP01","FP05","FP09","FP13"]
+        expected_signal_channel_names = ["FP01", "FP05", "FP09", "FP13"]
         assert_equal(signal_channel_names, expected_signal_channel_names)
 
         # Check that the names of the loaded spike channels match what we expect
         spike_channel_names = reader.header["spike_channels"]["name"].tolist()
         expected_spike_channel_names = ["SPK01.0", "SPK05.0", "SPK09.0", "SPK13.0"]
         assert_equal(spike_channel_names, expected_spike_channel_names)
 
+
 if __name__ == "__main__":
     unittest.main()