Fix conflict

Author: samuelgarcia

doc/source/authors.rst

@@ -60,6 +60,7 @@ and may not be the current affiliation of a contributor.
 * Etienne Combrisson [6]
 * Ben Dichter [24]
 * Elodie Legouée [21]
+* Heberto Mayorquin [24]
 * Thomas Perret [25]
 
 1. Centre de Recherche en Neuroscience de Lyon, CNRS UMR5292 - INSERM U1028 - Universite Claude Bernard Lyon 1

neo/io/neomatlabio.py

@@ -37,8 +37,8 @@
         SCIPY_ERR = None
 
 from neo.io.baseio import BaseIO
-from neo.core import (Block, Segment, AnalogSignal, Event, Epoch, SpikeTrain,
-                      objectnames, class_by_name)
+from neo.core import (Block, Segment, AnalogSignal, IrregularlySampledSignal,
+                      Event, Epoch, SpikeTrain, objectnames, class_by_name)
 
 classname_lower_to_upper = {}
 for k in objectnames:
@@ -190,7 +190,8 @@ class NeoMatlabIO(BaseIO):
     is_readable = True
     is_writable = True
 
-    supported_objects = [Block, Segment, AnalogSignal, Epoch, Event, SpikeTrain]
+    supported_objects = [Block, Segment, AnalogSignal, IrregularlySampledSignal,
+                         Epoch, Event, SpikeTrain]
     readable_objects = [Block]
     writeable_objects = [Block]
 
@@ -251,6 +252,10 @@ def write_block(self, bl, **kargs):
                 anasig_struct = self.create_struct_from_obj(anasig)
                 seg_struct['analogsignals'].append(anasig_struct)
 
+            for irrsig in seg.irregularlysampledsignals:
+                irrsig_struct = self.create_struct_from_obj(irrsig)
+                seg_struct['irregularlysampledsignals'].append(irrsig_struct)
+
             for ea in seg.events:
                 ea_struct = self.create_struct_from_obj(ea)
                 seg_struct['events'].append(ea_struct)
@@ -348,7 +353,13 @@ def create_ob_from_struct(self, struct, classname):
                 else:
                     data_complement["t_start"] = 0.0
 
-            ob = cl(arr, **data_complement)
+            if "times" in (at[0] for at in cl._necessary_attrs) and quantity_attr != "times":
+                # handle IrregularlySampledSignal
+                times = getattr(struct, "times")
+                data_complement["time_units"] = getattr(struct, "times_units")
+                ob = cl(times, arr, **data_complement)
+            else:
+                ob = cl(arr, **data_complement)
         else:
             ob = cl()
 

neo/io/neurosharectypesio.py

@@ -216,7 +216,12 @@ def read_segment(self, import_neuroshare_segment=True,
                                                     ctypes.POINTER(ctypes.c_double)))
                     total_read += pdwContCount.value
 
-                signal = pq.Quantity(pData, units=pAnalogInfo.szUnits.decode(), copy=False)
+                try:
+                    signal = pq.Quantity(pData, units=pAnalogInfo.szUnits.decode(), copy=False)
+                    unit_annotation = None
+                except LookupError:
+                    signal = pq.Quantity(pData, units='dimensionless', copy=False)
+                    unit_annotation = pAnalogInfo.szUnits.decode()
 
                 # t_start
                 dwIndex = 0
@@ -229,6 +234,8 @@ def read_segment(self, import_neuroshare_segment=True,
                                       name=str(entityInfo.szEntityLabel),
                                       )
                 anaSig.annotate(probe_info=str(pAnalogInfo.szProbeInfo))
+                if unit_annotation is not None:
+                    anaSig.annotate(units=unit_annotation)
                 seg.analogsignals.append(anaSig)
 
             # segment

neo/io/nixio.py

@@ -1167,7 +1167,7 @@ def _write_spiketrain(self, spiketrain, nixblock, nixgroup):
             return
 
         if isinstance(spiketrain, BaseProxy):
-            spiketrain = spiketrain.load()
+            spiketrain = spiketrain.load(load_waveforms=True)
 
         times = spiketrain.times.magnitude
         tunits = units_to_string(spiketrain.times.units)

neo/io/nwbio.py

@@ -561,6 +561,9 @@ def _write_signal(self, nwbfile, signal, electrodes):
             additional_metadata["conversion"] = conversion
         else:
             units = signal.units
+        if hasattr(signal, 'proxy_for') and signal.proxy_for in [AnalogSignal,
+                                                                 IrregularlySampledSignal]:
+            signal = signal.load()
         if isinstance(signal, AnalogSignal):
             sampling_rate = signal.sampling_rate.rescale("Hz")
             tS = timeseries_class(
@@ -597,20 +600,26 @@ def _write_signal(self, nwbfile, signal, electrodes):
         return tS
 
     def _write_spiketrain(self, nwbfile, spiketrain):
+        segment = spiketrain.segment
+        if hasattr(spiketrain, 'proxy_for') and spiketrain.proxy_for is SpikeTrain:
+            spiketrain = spiketrain.load()
         nwbfile.add_unit(spike_times=spiketrain.rescale('s').magnitude,
                          obs_intervals=[[float(spiketrain.t_start.rescale('s')),
                                          float(spiketrain.t_stop.rescale('s'))]],
                          _name=spiketrain.name,
                          # _description=spiketrain.description,
-                         segment=spiketrain.segment.name,
-                         block=spiketrain.segment.block.name)
+                         segment=segment.name,
+                         block=segment.block.name)
         # todo: handle annotations (using add_unit_column()?)
         # todo: handle Neo Units
         # todo: handle spike waveforms, if any (see SpikeEventSeries)
         return nwbfile.units
 
     def _write_event(self, nwbfile, event):
-        hierarchy = {'block': event.segment.block.name, 'segment': event.segment.name}
+        segment = event.segment
+        if hasattr(event, 'proxy_for') and event.proxy_for == Event:
+            event = event.load()
+        hierarchy = {'block': segment.block.name, 'segment': segment.name}
         tS_evt = AnnotationSeries(
             name=event.name,
             data=event.labels,
@@ -621,13 +630,16 @@ def _write_event(self, nwbfile, event):
         return tS_evt
 
     def _write_epoch(self, nwbfile, epoch):
+        segment = epoch.segment
+        if hasattr(epoch, 'proxy_for') and epoch.proxy_for == Epoch:
+            epoch = epoch.load()
         for t_start, duration, label in zip(epoch.rescale('s').magnitude,
                                             epoch.durations.rescale('s').magnitude,
                                             epoch.labels):
             nwbfile.add_epoch(t_start, t_start + duration, [label], [],
                               _name=epoch.name,
-                              segment=epoch.segment.name,
-                              block=epoch.segment.block.name)
+                              segment=segment.name,
+                              block=segment.block.name)
         return nwbfile.epochs
 
 

neo/rawio/neuroscoperawio.py

@@ -15,29 +15,43 @@
 Author: Samuel Garcia
 
 """
+from pathlib import Path
 
 from .baserawio import (BaseRawIO, _signal_channel_dtype, _signal_stream_dtype,
-                _spike_channel_dtype, _event_channel_dtype)
+                        _spike_channel_dtype, _event_channel_dtype)
 
 import numpy as np
 from xml.etree import ElementTree
 
 
 class NeuroScopeRawIO(BaseRawIO):
-    extensions = ['xml', 'dat']
+    extensions = ['xml', 'dat', 'lfp', 'eeg']
     rawmode = 'one-file'
 
-    def __init__(self, filename=''):
+    def __init__(self, filename='', binary_file=None):
+        """raw reader for Neuroscope
+
+        Parameters
+        ----------
+        filename : str, optional
+            Usually the file_path of an xml file
+        binary_file : _type_, optional
+            The binary data file corresponding to the xml file:
+            Supported formats: ['.dat', '.lfp', '.eeg']
+        """
         BaseRawIO.__init__(self)
         self.filename = filename
+        self.binary_file = binary_file
 
     def _source_name(self):
-        return self.filename.replace('.xml', '').replace('.dat', '')
+        return Path(self.filename).stem
 
     def _parse_header(self):
-        filename = self.filename.replace('.xml', '').replace('.dat', '')
+        # Load the right paths to xml and data
+        self._resolve_xml_and_data_paths()
 
-        tree = ElementTree.parse(filename + '.xml')
+        # Parse XML-file
+        tree = ElementTree.parse(self.xml_file_path)
         root = tree.getroot()
         acq = root.find('acquisitionSystem')
         nbits = int(acq.find('nBits').text)
@@ -64,7 +78,8 @@ def _parse_header(self):
         else:
             raise (NotImplementedError)
 
-        self._raw_signals = np.memmap(filename + '.dat', dtype=sig_dtype,
+        # Extract signal from the data file
+        self._raw_signals = np.memmap(self.data_file_path, dtype=sig_dtype,
                                       mode='r', offset=0).reshape(-1, nb_channel)
 
         # one unique stream
@@ -122,3 +137,43 @@ def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop,
             channel_indexes = slice(None)
         raw_signals = self._raw_signals[slice(i_start, i_stop), channel_indexes]
         return raw_signals
+
+    def _resolve_xml_and_data_paths(self):
+        file_path = Path(self.filename)
+        supported_data_extensions = ['.dat', '.lfp', '.eeg']
+        suffix = file_path.suffix
+        if suffix == '.xml':
+            xml_file_path = file_path
+            data_file_path = self.binary_file
+            # If no binary file provided iterate over the formats
+            if data_file_path is None:
+                for extension in supported_data_extensions:
+                    data_file_path = file_path.with_suffix(extension)
+                    if data_file_path.is_file():
+                        break
+                assert data_file_path.is_file(), "data binary not found for file " \
+                f"{data_file_path} with supported extensions: {supported_data_extensions}"
+        elif suffix == '':
+            xml_file_path = file_path.with_suffix(".xml")
+            data_file_path = self.binary_file
+            # Empty suffix to keep testing behavior with non-existing
+            # file passing for backwards compatibility
+            if data_file_path is None:
+                data_file_path = file_path.with_suffix(".dat")
+        elif suffix in supported_data_extensions:
+            xml_file_path = file_path.with_suffix(".xml")
+            data_file_path = file_path
+        else:
+            error_string = (
+                f"Format {suffix} not supported "
+                f"filename format should be {supported_data_extensions} or .xml"
+            )
+            raise KeyError(error_string)
+
+        msg = f"xml file not found at the expected location {xml_file_path}"
+        assert xml_file_path.is_file(), msg
+        msg = f"binary file not found at the expected location {data_file_path}"
+        assert data_file_path.is_file(), msg
+
+        self.xml_file_path = xml_file_path
+        self.data_file_path = data_file_path

neo/rawio/spikeglxrawio.py

@@ -45,6 +45,7 @@
 Some functions are copied from Graham Findlay
 """
 
+import warnings
 from .baserawio import (BaseRawIO, _signal_channel_dtype, _signal_stream_dtype,
                 _spike_channel_dtype, _event_channel_dtype)
 
@@ -255,6 +256,10 @@ def scan_files(dirname):
                 info['meta_file'] = str(meta_filename)
                 info['bin_file'] = str(bin_filename)
                 info_list.append(info)
+            
+            # Let see if this will be anoying or not.
+            if bin_filename.stat().st_size != meta['fileSizeBytes']:
+                warnings.warn('.meta file has faulty value for .bin file size on disc')
 
     # the segment index will depend on both 'gate_num' and 'trigger_num'
     # so we order by 'gate_num' then 'trigger_num'

neo/test/iotest/test_neomatlabio.py

@@ -3,8 +3,11 @@
 """
 
 import unittest
-
+from numpy.testing import assert_array_equal
 import quantities as pq
+
+from neo.core.analogsignal import AnalogSignal
+from neo.core.irregularlysampledsignal import IrregularlySampledSignal
 from neo import Block, Segment, SpikeTrain
 from neo.test.iotest.common_io_test import BaseTestIO
 from neo.io.neomatlabio import NeoMatlabIO, HAVE_SCIPY
@@ -21,8 +24,12 @@ def test_write_read_single_spike(self):
         seg = Segment('segment1')
         spiketrain1 = SpikeTrain([1] * pq.s, t_stop=10 * pq.s, sampling_rate=1 * pq.Hz)
         spiketrain1.annotate(yep='yop')
+        sig1 = AnalogSignal([4, 5, 6] * pq.A, sampling_period=1 * pq.ms)
+        irrsig1 = IrregularlySampledSignal([0, 1, 2] * pq.ms, [4, 5, 6] * pq.A)
         block1.segments.append(seg)
         seg.spiketrains.append(spiketrain1)
+        seg.analogsignals.append(sig1)
+        seg.irregularlysampledsignals.append(irrsig1)
 
         # write block
         filename = self.get_local_path('matlabiotestfile.mat')
@@ -36,6 +43,14 @@ def test_write_read_single_spike(self):
         self.assertEqual(block1.segments[0].spiketrains[0],
                          block2.segments[0].spiketrains[0])
 
+        assert_array_equal(block1.segments[0].analogsignals[0],
+                            block2.segments[0].analogsignals[0])
+
+        assert_array_equal(block1.segments[0].irregularlysampledsignals[0].magnitude,
+                           block2.segments[0].irregularlysampledsignals[0].magnitude)
+        assert_array_equal(block1.segments[0].irregularlysampledsignals[0].times,
+                           block2.segments[0].irregularlysampledsignals[0].times)
+
         # test annotations
         spiketrain2 = block2.segments[0].spiketrains[0]
         assert 'yep' in spiketrain2.annotations

neo/test/iotest/test_neuroshareio.py

@@ -65,12 +65,12 @@ def setUp(self):
             raise unittest.SkipTest("Not currently supported on OS X")
 
     def test_with_multichannel(self):
-        filename0 = self.get_local_path(self.files_to_test[0])
-        reader = NeuroshareIO(filename0, self.dllname)
-        blocks = reader.read()
-        n = len(blocks[0].segments[0].analogsignals)
-        assert n == 2, \
-            'For {} , nb AnalogSignal: {} (should be 2)'.format(self.files_to_download[0], n)
+        for filename in self.files_to_test:
+            filename = self.get_local_path(filename)
+            reader = NeuroshareIO(filename, self.dllname)
+            blocks = reader.read()
+            n = len(blocks[0].segments[0].analogsignals)
+            assert n > 0, f'Expect signals in file {filename}'
 
 
 if __name__ == "__main__":

neo/test/iotest/test_nixio.py

@@ -168,8 +168,10 @@ def compare_signal_dalist(self, neosig, nixdalist):
     def compare_eests_mtags(self, eestlist, mtaglist):
         self.assertEqual(len(eestlist), len(mtaglist))
         for eest in eestlist:
-            if isinstance(eest, (EventProxy, EpochProxy, SpikeTrainProxy)):
+            if isinstance(eest, (EventProxy, EpochProxy)):
                 eest = eest.load()
+            elif isinstance(eest, SpikeTrainProxy):
+                eest = eest.load(load_waveforms=True)
             mtag = mtaglist[eest.annotations["nix_name"]]
             if isinstance(eest, Epoch):
                 self.compare_epoch_mtag(eest, mtag)