Merge branch 'master' into neuronexus

Author: zm711

neo/rawio/__init__.py

@@ -7,7 +7,7 @@
 
 Functions:
 
-.. autofunction:: neo.rawio.get_rawio_class
+.. autofunction:: neo.rawio.get_rawio
 
 
 Classes:
@@ -181,7 +181,8 @@
 
 """
 
-import os
+from pathlib import Path
+from collections import Counter
 
 from neo.rawio.alphaomegarawio import AlphaOmegaRawIO
 from neo.rawio.axographrawio import AxographRawIO
@@ -262,23 +263,58 @@ def get_rawio_class(filename_or_dirname):
 
     import warnings
 
-    warnings.warn("get_rawio_class is deprecated. In the future please use get_rawio")
+    warnings.warn(
+        "get_rawio_class is deprecated and will be removed in 0.15.0. " "In the future please use `get_rawio`"
+    )
 
     return get_rawio(filename_or_dirname)
 
 
-def get_rawio(filename_or_dirname):
+def get_rawio(filename_or_dirname, exclusive_rawio: bool = True):
     """
     Return a neo.rawio class guess from file extension.
+
+    Parameters
+    ----------
+    filename_or_dirname : str | Path
+        The filename or directory name to check for file suffixes that 
+        can be read by Neo. This can also be used to check whether a 
+        rawio could read a not-yet written file
+    exclusive_rawio: bool, default: True
+        Whether to return a rawio if there is only one rawio capable of
+        reading the file. If this doesn't exist will return None.
+        If set to False it will return all possible rawios organized
+        by the most likely rawio.
+    
+    Returns
+    -------
+    possibles: neo.RawIO | None | list[neo.RawIO]
+        If exclusive_rawio is True, returns the single RawIO that 
+        can read a file/set of files or None. If exclusive_rawio is
+        False it will return all possible RawIOs (organized by most likely) 
+        that could read the file or files.
     """
-    _, ext = os.path.splitext(filename_or_dirname)
-    ext = ext[1:]
+    filename_or_dirname = Path(filename_or_dirname)
+
+    # if filename_or_dirname doesn't exist then user may just be checking if
+    # neo can read their file or they give a real file
+    if not filename_or_dirname.exists() or filename_or_dirname.is_file():
+        ext = Path(filename_or_dirname).suffix
+        ext_list = [ext[1:]]
+    else:
+        ext_list = list({filename.suffix[1:] for filename in filename_or_dirname.glob('*') if filename.is_file()})
+    
     possibles = []
-    for rawio in rawiolist:
-        if any(ext.lower() == ext2.lower() for ext2 in rawio.extensions):
-            possibles.append(rawio)
+    for ext in ext_list:
+        for rawio in rawiolist:
+            if any(ext.lower() == ext2.lower() for ext2 in rawio.extensions):
+                possibles.append(rawio)
 
-    if len(possibles) == 1:
+    if len(possibles) == 1 and exclusive_rawio:
         return possibles[0]
-    else:
+    elif exclusive_rawio:
         return None
+    else:
+        possibles = [io[0] for io in Counter(possibles).most_common()]
+        return possibles
+

neo/rawio/neuralynxrawio/neuralynxrawio.py

@@ -213,7 +213,7 @@ def _parse_header(self):
         event_annotations = []
 
         if self.rawmode == "one-dir":
-            filenames = os.listdir(self.dirname)
+            filenames = sorted(os.listdir(self.dirname))
         else:
             filenames = self.include_filenames
 

neo/rawio/rawbinarysignalrawio.py

@@ -36,7 +36,7 @@ class RawBinarySignalRawIO(BaseRawIO):
     Parameters
     ----------
     filename: str, default: ''
-        The *.raw or *.bin binary file to load
+        The *.raw, *.bin, or *.dat binary file to load
     dtype: np.dtype, default: 'int16'
         The dtype that the data is stored with. Must be acceptable by the numpy.dtype constructor
     sampling_rate: float, default: 10000.0
@@ -51,7 +51,7 @@ class RawBinarySignalRawIO(BaseRawIO):
         The offset for the bytes
     """
 
-    extensions = ["raw", "bin"]
+    extensions = ["raw", "bin", "dat"]
     rawmode = "one-file"
 
     def __init__(

neo/rawio/spikegadgetsrawio.py

@@ -20,17 +20,18 @@
 Author: Samuel Garcia
 """
 
+import numpy as np
+
+from xml.etree import ElementTree
+
 from .baserawio import (
     BaseRawIO,
     _signal_channel_dtype,
     _signal_stream_dtype,
     _spike_channel_dtype,
     _event_channel_dtype,
 )
-
-import numpy as np
-
-from xml.etree import ElementTree
+from neo.core import NeoReadWriteError
 
 
 class SpikeGadgetsRawIO(BaseRawIO):
@@ -79,6 +80,24 @@ def __init__(self, filename="", selected_streams=None):
     def _source_name(self):
         return self.filename
 
+    def _produce_ephys_channel_ids(self, n_total_channels, n_channels_per_chip):
+        """Compute the channel ID labels
+        The ephys channels in the .rec file are stored in the following order:
+        hwChan ID of channel 0 of first chip, hwChan ID of channel 0 of second chip, ..., hwChan ID of channel 0 of Nth chip,
+        hwChan ID of channel 1 of first chip, hwChan ID of channel 1 of second chip, ..., hwChan ID of channel 1 of Nth chip,
+        ...
+        So if there are 32 channels per chip and 128 channels (4 chips), then the channel IDs are:
+        0, 32, 64, 96, 1, 33, 65, 97, ..., 128
+        See also: https://github.com/NeuralEnsemble/python-neo/issues/1215
+        """
+        ephys_channel_ids_list = []
+        for hw_channel in range(n_channels_per_chip):
+            hw_channel_list = [
+                hw_channel + chip * n_channels_per_chip for chip in range(int(n_total_channels / n_channels_per_chip))
+            ]
+            ephys_channel_ids_list.append(hw_channel_list)
+        return [channel for channel_list in ephys_channel_ids_list for channel in channel_list]
+
     def _parse_header(self):
         # parse file until "</Configuration>"
         header_size = None
@@ -104,6 +123,20 @@ def _parse_header(self):
         self._sampling_rate = float(hconf.attrib["samplingRate"])
         num_ephy_channels = int(hconf.attrib["numChannels"])
 
+        # check for agreement with number of channels in xml
+        sconf_channels = np.sum([len(x) for x in sconf])
+        if sconf_channels < num_ephy_channels:
+            num_ephy_channels = sconf_channels
+        if sconf_channels > num_ephy_channels:
+            raise NeoReadWriteError(
+                "SpikeGadgets: the number of channels in the spike configuration is larger than the number of channels in the hardware configuration"
+            )
+
+        try:
+            num_chan_per_chip = int(sconf.attrib["chanPerChip"])
+        except KeyError:
+            num_chan_per_chip = 32  # default value for Intan chips
+
         # explore sub stream and count packet size
         # first bytes is 0x55
         packet_size = 1
@@ -174,6 +207,7 @@ def _parse_header(self):
             signal_streams.append((stream_name, stream_id))
             self._mask_channels_bytes[stream_id] = []
 
+            channel_ids = self._produce_ephys_channel_ids(num_ephy_channels, num_chan_per_chip)
             chan_ind = 0
             self.is_scaleable = "spikeScalingToUv" in sconf[0].attrib
             if not self.is_scaleable:
@@ -190,8 +224,8 @@ def _parse_header(self):
                     units = ""
 
                 for schan in trode:
-                    name = "trode" + trode.attrib["id"] + "chan" + schan.attrib["hwChan"]
-                    chan_id = schan.attrib["hwChan"]
+                    chan_id = str(channel_ids[chan_ind])
+                    name = "hwChan" + chan_id
 
                     offset = 0.0
                     signal_channels.append(