Merge branch 'master' into enh/get_io

Author: JuliaSprenger

.github/workflows/core-test.yml

@@ -35,12 +35,12 @@ jobs:
              numpy-version: '1.20.3'
     steps:
         - name: Set up Python ${{ matrix.python-version }}
-          uses: actions/setup-python@v2
+          uses: actions/setup-python@v4
           with:
             python-version: ${{ matrix.python-version }}
 
         - name: Checkout repository
-          uses: actions/checkout@v2
+          uses: actions/checkout@v3
 
         - name: Install numpy ${{ matrix.numpy-version }}
           run: |

.github/workflows/io-test.yml

@@ -27,24 +27,24 @@ jobs:
     steps:
 
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Get current year-month
         id: date
-        run: echo "::set-output name=date::$(date +'%Y-%m')"
+        run: echo "date=$(date +'%Y-%m')" >> $GITHUB_OUTPUT
 
       - name: Get ephy_testing_data current head hash
         # the key depend on the last commit repo https://gin.g-node.org/NeuralEnsemble/ephy_testing_data.git
-        id: vars
+        id: ephy_testing_data_hash
         run: |
-          echo "::set-output name=HASH_EPHY_DATASET::$(git ls-remote https://gin.g-node.org/NeuralEnsemble/ephy_testing_data.git HEAD | cut -f1)"
+          echo "latest_hash=$(git ls-remote https://gin.g-node.org/NeuralEnsemble/ephy_testing_data.git HEAD | cut -f1)" >> GITHUB_OUTPUT
 
       - uses: actions/cache@v3
         # Loading cache of ephys_testing_dataset
         id: cache-datasets
         with:
           path: ~/ephy_testing_data
-          key: ${{ runner.os }}-datasets-${{ steps.vars.outputs.HASH_EPHY_DATASET }}
+          key: ${{ runner.os }}-datasets-${{ steps.ephy_testing_data_hash.outputs.latest_hash }}
 
       - uses: conda-incubator/setup-miniconda@v2
         with:

neo/core/epoch.py

@@ -175,7 +175,14 @@ def __repr__(self):
         return '<Epoch: %s>' % ', '.join(objs)
 
     def _repr_pretty_(self, pp, cycle):
-        super()._repr_pretty_(pp, cycle)
+        labels = ""
+        if self._labels is not None:
+            labels = " with labels"
+        pp.text(f"{self.__class__.__name__} containing {self.size} epochs{labels}; "
+        f"time units {self.units.dimensionality.string}; datatype {self.dtype} ")
+        if self._has_repr_pretty_attrs_():
+            pp.breakable()
+            self._repr_pretty_attrs_(pp, cycle)
 
     def rescale(self, units):
         '''

neo/core/event.py

@@ -148,7 +148,14 @@ def __repr__(self):
         return '<Event: %s>' % ', '.join(objs)
 
     def _repr_pretty_(self, pp, cycle):
-        super()._repr_pretty_(pp, cycle)
+        labels = ""
+        if self._labels is not None:
+            labels = " with labels"
+        pp.text(f"{self.__class__.__name__} containing {self.size} events{labels}; "
+        f"time units {self.units.dimensionality.string}; datatype {self.dtype} ")
+        if self._has_repr_pretty_attrs_():
+            pp.breakable()
+            self._repr_pretty_attrs_(pp, cycle)
 
     def rescale(self, units):
         '''

neo/core/spiketrain.py

@@ -346,7 +346,21 @@ def __init__(self, times, t_stop, units=None, dtype=None, copy=True,
                             array_annotations=array_annotations, **annotations)
 
     def _repr_pretty_(self, pp, cycle):
-        super()._repr_pretty_(pp, cycle)
+        waveforms = ""
+        if self.waveforms:
+            waveforms = "with waveforms"
+        pp.text(f"{self.__class__.__name__} containing {self.size} spikes{waveforms}; "
+                f"units {self.units.dimensionality.string}; datatype {self.dtype} ")
+        if self._has_repr_pretty_attrs_():
+            pp.breakable()
+            self._repr_pretty_attrs_(pp, cycle)
+
+        def _pp(line):
+            pp.breakable()
+            with pp.group(indent=1):
+                pp.text(line)
+
+        _pp(f"time: {self.t_start} to {self.t_stop}")
 
     def rescale(self, units):
         '''

neo/io/klustakwikio.py

@@ -15,10 +15,10 @@
 
 import glob
 import logging
-import os.path
+from pathlib import Path
 import shutil
 
-# note neo.core need only numpy and quantitie
+# note neo.core need only numpy and quantities
 import numpy as np
 
 
@@ -87,27 +87,31 @@ class KlustaKwikIO(BaseIO):
     extensions = ['fet', 'clu', 'res', 'spk']
 
     # Operates on directories
-    mode = 'file'
+    mode = 'dir'
 
-    def __init__(self, filename, sampling_rate=30000.):
+    def __init__(self, dirname, sampling_rate=30000.):
         """Create a new IO to operate on a directory
 
-        filename : the directory to contain the files
-        basename : string, basename of KlustaKwik format, or None
+        dirname : the directory to contain the files
         sampling_rate : in Hz, necessary because the KlustaKwik files
             stores data in samples.
         """
         BaseIO.__init__(self)
-        # self.filename = os.path.normpath(filename)
-        self.filename, self.basename = os.path.split(os.path.abspath(filename))
+        self.dirname = Path(dirname)
+        # in case no basename is provided
+        if self.dirname.is_dir():
+            self.session_dir = self.dirname
+        else:
+            self.session_dir = self.dirname.parent
+            self.basename = self.dirname.name
         self.sampling_rate = float(sampling_rate)
 
         # error check
-        if not os.path.isdir(self.filename):
-            raise ValueError("filename must be a directory")
+        if not self.session_dir.is_dir():
+            raise ValueError("dirname must be in an existing directory")
 
         # initialize a helper object to parse filenames
-        self._fp = FilenameParser(dirname=self.filename, basename=self.basename)
+        self._fp = FilenameParser(dirname=self.session_dir, basename=self.basename)
 
     def read_block(self, lazy=False):
         """Returns a Block containing spike information.
@@ -130,7 +134,7 @@ def read_block(self, lazy=False):
             return block
 
         # Create a single segment to hold all of the data
-        seg = Segment(name='seg0', index=0, file_origin=self.filename)
+        seg = Segment(name='seg0', index=0, file_origin=str(self.session_dir / self.basename))
         block.segments.append(seg)
 
         # Load spike times from each group and store in a dict, keyed
@@ -367,15 +371,13 @@ def _make_all_file_handles(self, block):
 
     def _new_group(self, id_group, nbClusters):
         # generate filenames
-        fetfilename = os.path.join(self.filename,
-                                   self.basename + ('.fet.%d' % id_group))
-        clufilename = os.path.join(self.filename,
-                                   self.basename + ('.clu.%d' % id_group))
+        fetfilename = self.session_dir / (self.basename + ('.fet.%d' % id_group))
+        clufilename = self.session_dir / (self.basename + ('.clu.%d' % id_group))
 
         # back up before overwriting
-        if os.path.exists(fetfilename):
+        if fetfilename.exists():
             shutil.copyfile(fetfilename, fetfilename + '~')
-        if os.path.exists(clufilename):
+        if clufilename.exists():
             shutil.copyfile(clufilename, clufilename + '~')
 
         # create file handles
@@ -406,12 +408,12 @@ def __init__(self, dirname, basename=None):
         will be used. An error is raised if files with multiple basenames
         exist in the directory.
         """
-        self.dirname = os.path.normpath(dirname)
+        self.dirname = Path(dirname).absolute()
         self.basename = basename
 
         # error check
-        if not os.path.isdir(self.dirname):
-            raise ValueError("filename must be a directory")
+        if not self.dirname.is_dir():
+            raise ValueError("dirname must be a directory")
 
     def read_filenames(self, typestring='fet'):
         """Returns filenames in the data directory matching the type.
@@ -430,13 +432,13 @@ def read_filenames(self, typestring='fet'):
         a sequence of digits are valid. The digits are converted to an integer
         and used as the group number.
         """
-        all_filenames = glob.glob(os.path.join(self.dirname, '*'))
+        all_filenames = self.dirname.glob('*')
 
         # Fill the dict with valid filenames
         d = {}
         for v in all_filenames:
             # Test whether matches format, ie ends with digits
-            split_fn = os.path.split(v)[1]
+            split_fn = v.name
             m = glob.re.search((r'^(\w+)\.%s\.(\d+)$' % typestring), split_fn)
             if m is not None:
                 # get basename from first hit if not specified

neo/io/neuroshareapiio.py

@@ -77,26 +77,29 @@ class NeuroshareapiIO(BaseIO):
     # This object operates on neuroshare files
     mode = "file"
 
-    def __init__(self, filename=None, dllpath=None):
+    def __init__(self, filename=None, dllname=None):
         """
         Arguments:
             filename : the filename
+            dllname: the path of the library to use for reading
         The init function will run automatically upon calling of the class, as
         in: test = MultichannelIO(filename = filetoberead.mcd), therefore the first
         operations with the file are set here, so that the user doesn't have to
         remember to use another method, than the ones defined in the NEO library
 
         """
         BaseIO.__init__(self)
-        self.filename = filename
+        self.filename = str(filename)
         # set the flags for each event type
         eventID = 1
         analogID = 2
         epochID = 3
         # if a filename was given, create a dictionary with information that will
         # be needed later on.
         if self.filename is not None:
-            if dllpath is not None:
+            if dllname is not None:
+                # converting to string to also accept pathlib objects
+                dllpath = str(dllname)
                 name = os.path.splitext(os.path.basename(dllpath))[0]
                 library = ns.Library(name, dllpath)
             else:
@@ -330,13 +333,13 @@ def read_spiketrain(self,
         numIndx = endat - startat
         # get the end point using segment duration
         # create a numpy empty array to store the waveforms
-        waveforms = np.array(np.zeros([numIndx, tempSpks.max_sample_count]))
+        waveforms = np.array(np.zeros([numIndx, 1, tempSpks.max_sample_count]))
         # loop through the data from the specific channel index
         for i in range(startat, endat, 1):
             # get cutout, timestamp, cutout duration, and spike unit
             tempCuts, timeStamp, duration, unit = tempSpks.get_data(i)
             # save the cutout in the waveform matrix
-            waveforms[i] = tempCuts[0]
+            waveforms[i, 0, :] = tempCuts[0]
             # append time stamp to list
             times.append(timeStamp)
 

neo/io/neurosharectypesio.py

@@ -119,7 +119,7 @@ def __init__(self, filename='', dllname=''):
         """
         BaseIO.__init__(self)
         self.dllname = dllname
-        self.filename = filename
+        self.filename = str(filename)
 
     def read_segment(self, import_neuroshare_segment=True,
                      lazy=False):

neo/rawio/openephysbinaryrawio.py

@@ -205,7 +205,7 @@ def _parse_header(self):
                         raise ValueError(f'There is no possible labels for this event: {stream_name}')
 
                     # # If available, use 'states' to compute event duration
-                    if 'states' in d:
+                    if 'states' in d and d["states"].size:
                         states = d["states"]
                         timestamps = d["timestamps"]
                         labels = d["labels"]