Merge branch 'master' into fix_intan_one_file_per_channel

Author: zm711

.github/workflows/core-test.yml

@@ -25,28 +25,43 @@ jobs:
       fail-fast: true
       matrix:
         os: ["ubuntu-latest", "windows-latest", "macos-latest"]
-        python-version: ['3.9', '3.10', '3.11', '3.12']
-        numpy-version: ['1.22.4', '1.23.5', '1.24.1', '1.25.1', '1.26.4']
+        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
+        numpy-version: ['1.22.4', '1.23.5', '1.24.4', '1.25.1', '1.26.4', '2.0.2','2.1']
         # numpy 1.22: 3.10, 1.23: 3.11, 1.24: 3.11, 1.25: 3.11, 1.26: 3.12
         exclude:
+           - python-version: '3.9'
+             numpy-version: '2.1'
            - python-version: '3.11'
              numpy-version: '1.22.4'
            - python-version: '3.12'
              numpy-version: '1.22.4'
            - python-version: '3.12'
              numpy-version: '1.23.5'
            - python-version: '3.12'
-             numpy-version: '1.24.1'
+             numpy-version: '1.24.4'
            - python-version: '3.12'
              numpy-version: '1.25.1'
+           - python-version: '3.13'
+             numpy-version: '1.22.4'
+           - python-version: '3.13'
+             numpy-version: '1.23.5'
+           - python-version: '3.13'
+             numpy-version: '1.24.4'
+           - python-version: '3.13'
+             numpy-version: '1.25.1'
+           - python-version: '3.13'
+             numpy-version: '1.26.4'
+           - python-version: '3.13'
+             numpy-version: '2.0.2'
+
     steps:
         - name: Set up Python ${{ matrix.python-version }}
-          uses: actions/setup-python@v4
+          uses: actions/setup-python@v5
           with:
             python-version: ${{ matrix.python-version }}
 
         - name: Checkout repository
-          uses: actions/checkout@v3
+          uses: actions/checkout@v4
 
         - name: Install numpy ${{ matrix.numpy-version }}
           run: |

.github/workflows/io-test.yml

@@ -18,15 +18,15 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        python-version: ['3.9', '3.11.9']
+        python-version: ['3.9', '3.12']
     defaults:
       # by default run in bash mode (required for conda usage)
       run:
         shell: bash -l {0}
     steps:
 
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Get current year-month
         id: date
@@ -38,7 +38,7 @@ jobs:
         run: |
           echo "dataset_hash=$(git ls-remote https://gin.g-node.org/NeuralEnsemble/ephy_testing_data.git HEAD | cut -f1)" >> $GITHUB_OUTPUT
 
-      - uses: actions/cache/restore@v3
+      - uses: actions/cache/restore@v4
         # Loading cache of ephys_testing_dataset
         id: cache-datasets
         with:

environment_testing.yml

@@ -4,3 +4,6 @@ channels:
 dependencies:
   - datalad
   - pip
+  # temporary have this here for IO testing while we decide how to deal with
+  # external packages not 2.0 ready
+  - numpy=1.26.4

neo/core/spiketrain.py

@@ -979,7 +979,7 @@ def _merge_array_annotations(self, others, sorting=None):
 
         omitted_keys_other = [
             key
-            for key in np.unique([key for other in others for key in other.array_annotations])
+            for key in set([key for other in others for key in other.array_annotations])
             if key not in self.array_annotations
         ]
 

neo/rawio/__init__.py

@@ -29,7 +29,7 @@
 * :attr:`MicromedRawIO`
 * :attr:`NeuralynxRawIO`
 * :attr:`NeuroExplorerRawIO`
-* :attr:`NeuroNexusRawIO
+* :attr:`NeuroNexusRawIO`
 * :attr:`NeuroScopeRawIO`
 * :attr:`NIXRawIO`
 * :attr:`OpenEphysRawIO`

neo/rawio/openephysbinaryrawio.py

@@ -217,7 +217,6 @@ def _parse_header(self):
                         if name + "_npy" in info:
                             data = np.load(info[name + "_npy"], mmap_mode="r")
                             info[name] = data
-
                     # check that events have timestamps
                     assert "timestamps" in info, "Event stream does not have timestamps!"
                     # Updates for OpenEphys v0.6:
@@ -253,30 +252,64 @@ def _parse_header(self):
                     # 'states' was introduced in OpenEphys v0.6. For previous versions, events used 'channel_states'
                     if "states" in info or "channel_states" in info:
                         states = info["channel_states"] if "channel_states" in info else info["states"]
+
                         if states.size > 0:
                             timestamps = info["timestamps"]
                             labels = info["labels"]
-                            rising = np.where(states > 0)[0]
-                            falling = np.where(states < 0)[0]
 
-                            # infer durations
+                            # Identify unique channels based on state values
+                            channels = np.unique(np.abs(states))
+
+                            rising_indices = []
+                            falling_indices = []
+
+                            # all channels are packed into the same `states` array.
+                            # So the states array includes positive and negative values for each channel:
+                            #  for example channel one rising would be +1 and channel one falling would be -1,
+                            # channel two rising would be +2 and channel two falling would be -2, etc.
+                            # This is the case for sure for version >= 0.6.x.
+                            for channel in channels:
+                                # Find rising and falling edges for each channel
+                                rising = np.where(states == channel)[0]
+                                falling = np.where(states == -channel)[0]
+
+                                # Ensure each rising has a corresponding falling
+                                if rising.size > 0 and falling.size > 0:
+                                    if rising[0] > falling[0]:
+                                        falling = falling[1:]
+                                    if rising.size > falling.size:
+                                        rising = rising[:-1]
+
+                                    # ensure that the number of rising and falling edges are the same:
+                                    if len(rising) != len(falling):
+                                        warn(
+                                            f"Channel {channel} has {len(rising)} rising edges and "
+                                            f"{len(falling)} falling edges. The number of rising and "
+                                            f"falling edges should be equal. Skipping events from this channel."
+                                        )
+                                        continue
+
+                                    rising_indices.extend(rising)
+                                    falling_indices.extend(falling)
+
+                            rising_indices = np.array(rising_indices)
+                            falling_indices = np.array(falling_indices)
+
+                            # Sort the indices to maintain chronological order
+                            sorted_order = np.argsort(rising_indices)
+                            rising_indices = rising_indices[sorted_order]
+                            falling_indices = falling_indices[sorted_order]
+
                             durations = None
-                            if len(states) > 0:
-                                # make sure first event is rising and last is falling
-                                if states[0] < 0:
-                                    falling = falling[1:]
-                                if states[-1] > 0:
-                                    rising = rising[:-1]
-
-                                if len(rising) == len(falling):
-                                    durations = timestamps[falling] - timestamps[rising]
-                                    if not self._use_direct_evt_timestamps:
-                                        timestamps = timestamps / info["sample_rate"]
-                                        durations = durations / info["sample_rate"]
-
-                            info["rising"] = rising
-                            info["timestamps"] = timestamps[rising]
-                            info["labels"] = labels[rising]
+                            # if len(rising_indices) == len(falling_indices):
+                            durations = timestamps[falling_indices] - timestamps[rising_indices]
+                            if not self._use_direct_evt_timestamps:
+                                timestamps = timestamps / info["sample_rate"]
+                                durations = durations / info["sample_rate"]
+
+                            info["rising"] = rising_indices
+                            info["timestamps"] = timestamps[rising_indices]
+                            info["labels"] = labels[rising_indices]
                             info["durations"] = durations
 
         # no spike read yet

neo/test/coretest/test_spiketrain.py

@@ -313,6 +313,10 @@ def test__create_from_quantity_array(self):
 
     def test__create_from_quantity_array_with_dtype(self):
         times = np.arange(10, dtype="f4") * pq.ms
+        # this step is required for NumPy 2.0 which now casts to float64 in the case either value/array
+        # is float64 even if not necessary
+        # https://numpy.org/devdocs/numpy_2_0_migration_guide.html
+        times = times.astype(dtype="f4")
         t_start = 0.0 * pq.s
         t_stop = 12.0 * pq.ms
         train1 = SpikeTrain(times, t_start=t_start, t_stop=t_stop)
@@ -343,6 +347,10 @@ def test__create_from_quantity_array_no_start_stop_units(self):
 
     def test__create_from_quantity_array_no_start_stop_units_with_dtype(self):
         times = np.arange(10, dtype="f4") * pq.ms
+        # this step is required for NumPy 2.0 which now casts to float64 in the case either value/array
+        # is float64 even if not necessary
+        # https://numpy.org/devdocs/numpy_2_0_migration_guide.html
+        times = times.astype(dtype="f4")
         t_start = 0.0
         t_stop = 12.0
         train1 = SpikeTrain(times, t_start=t_start, t_stop=t_stop)
@@ -1143,7 +1151,7 @@ def test_merge_multiple(self):
         expected *= time_unit
         sorting = np.argsort(expected)
         expected = expected[sorting]
-        np.testing.assert_array_equal(result.times, expected)
+        np.testing.assert_array_equal(result.times.magnitude, expected.magnitude)
 
         # Make sure array annotations are merged correctly
         self.assertTrue("label" not in result.array_annotations)

neo/test/rawiotest/test_openephysbinaryrawio.py

@@ -3,6 +3,8 @@
 from neo.rawio.openephysbinaryrawio import OpenEphysBinaryRawIO
 from neo.test.rawiotest.common_rawio_test import BaseTestRawIO
 
+import numpy as np
+
 
 class TestOpenEphysBinaryRawIO(BaseTestRawIO, unittest.TestCase):
     rawioclass = OpenEphysBinaryRawIO
@@ -57,6 +59,25 @@ def test_missing_folders(self):
             )
             rawio.parse_header()
 
+    def test_multiple_ttl_events_parsing(self):
+        rawio = OpenEphysBinaryRawIO(
+            self.get_local_path("openephysbinary/v0.6.x_neuropixels_with_sync"), load_sync_channel=False
+        )
+        rawio.parse_header()
+        rawio.header = rawio.header
+        # Testing co
+        # This is the TTL events from the NI Board channel
+        ttl_events = rawio._evt_streams[0][0][1]
+        assert "rising" in ttl_events.keys()
+        assert "labels" in ttl_events.keys()
+        assert "durations" in ttl_events.keys()
+        assert "timestamps" in ttl_events.keys()
+
+        # Check that durations of different event streams are correctly parsed:
+        assert np.allclose(ttl_events["durations"][ttl_events["labels"] == "1"], 0.5, atol=0.001)
+        assert np.allclose(ttl_events["durations"][ttl_events["labels"] == "6"], 0.025, atol=0.001)
+        assert np.allclose(ttl_events["durations"][ttl_events["labels"] == "7"], 0.016666, atol=0.001)
+
 
 if __name__ == "__main__":
     unittest.main()

pyproject.toml

@@ -4,7 +4,7 @@ version = "0.14.0.dev0"
 authors = [{name = "Neo authors and contributors"}]
 description = "Neo is a package for representing electrophysiology data in Python, together with support for reading a wide range of neurophysiology file formats"
 readme = "README.rst"
-requires-python = ">=3.9,<3.13" # 3.13 will require NumPy > 2.0 (Windows issue in CI)
+requires-python = ">=3.9"
 license = {text = "BSD 3-Clause License"}
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -23,7 +23,7 @@ classifiers = [
 
 dependencies = [
     "packaging",
-    "numpy>=1.22.4,<2.0.0",
+    "numpy>=1.22.4",
     "quantities>=0.16.1"
 ]
 
@@ -45,7 +45,7 @@ iocache = [
 ]
 
 test = [
-    "dhn_med_py<2.0", # ci failing with 2.0 test future version when stable
+    # "dhn_med_py<2.0", # ci failing with 2.0 test future version when stable
     "pytest",
     "pytest-cov",
     # datalad   # this dependency is covered by conda (environment_testing.yml)
@@ -105,7 +105,7 @@ plexon2 = ["zugbruecke>=0.2; sys_platform!='win32'", "wenv; sys_platform!='win32
 all = [
     "coverage",
     "coveralls",
-    "dhn_med_py<2.0", # ci failing with 2.0 test future version when stable
+    # "dhn_med_py<2.0", # ci failing with 2.0 test future version when stable
     "h5py",
     "igor2",
     "ipython",