Merge pull request #537 from jgrewe/invalid_event_slices

Invalid event slices

Author: mpsonntag

.github/workflows/pythonpackage.yml

@@ -2,8 +2,8 @@ name: NIXPy tests and linting
 
 on:
   # Run one build a month at 01:00
-  schedule:
-  - cron:  '0 1 1 * *'
+  # schedule:
+  # - cron:  '0 1 1 * *'
   push:
     branches:
       - master

nixio/data_array.py

@@ -316,6 +316,8 @@ def get_slice(self, positions, extents=None, mode=DataSliceMode.Index):
         ```
 
         Note: The extents are *not* the end positions but the extent of the slice!
+        In the case of regularly sampled dimensions, reaching beyond the start of end of the respective dimension will cause an exception. For irregularly sampled data no 
+        exception will be raised but the returned DataView might be invalid and empty.
 
         :param positions: Specifies the start of the data slice. List of either indices or data positions depending on the DataSliceMode.
         :type positions: list length must match dimensionality of the data.
@@ -360,13 +362,29 @@ def get_slice(self, positions, extents=None, mode=DataSliceMode.Index):
     def _get_slice_bydim(self, positions, extents):
         dpos, dext = [], []
         for dim, pos, ext in zip(self.dimensions, positions, extents):
-            if dim.dimension_type in (DimensionType.Sample,
-                                      DimensionType.Range):
-                dpos.append(dim.index_of(pos, mode=IndexMode.GreaterOrEqual))
-                dext.append(dim.index_of(pos + ext) - dpos[-1])
+            if dim.dimension_type == DimensionType.Sample:
+                start_pos = dim.index_of(pos, mode=IndexMode.GreaterOrEqual)
+                extent = dim.index_of(pos + ext) - start_pos
+            elif dim.dimension_type == DimensionType.Range:
+                try:
+                    start_pos = dim.index_of(pos, mode=IndexMode.GreaterOrEqual)
+                    extent = dim.index_of(pos + ext) - start_pos
+                except IndexError:
+                    start_pos = -1
+                    extent = -1
+                except Exception as e:
+                    raise e
             elif dim.dimension_type == DimensionType.Set:
-                dpos.append(int(pos))
-                dext.append(int(ext))
+                start_pos = int(pos)
+                extent = int(ext)
+            else:
+                raise IncompatibleDimensions(f"Unknown dimension type: {dim.dimension_type}",
+                                             "data_array._get_slice_by_dim")
+
+            if extent < 0:
+                return DataView(self, None)
+            dpos.append(start_pos)
+            dext.append(extent)
         slices = tuple(slice(p, p + e) for p, e in zip(dpos, dext))
         return DataView(self, slices)
 

nixio/dimensions.py

@@ -693,7 +693,7 @@ def range_indices(self, start_position, end_position, mode=SliceMode.Exclusive):
         :raises: ValueError if invalid mode is given
         :raises: Index Error if start position is greater than end position.
         """
-        if mode is not SliceMode.Exclusive and mode is not SliceMode.Inclusive:
+        if mode not in (SliceMode.Exclusive, SliceMode.Inclusive):
             raise ValueError("Unknown SliceMode: {}".format(mode))
         if start_position > end_position:
             raise IndexError("Start position {} is greater than end position {}.".format(start_position, end_position))

nixio/tag.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright © 2014, German Neuroinformatics Node (G-Node)
+# Copyright © 2014 - 2022, German Neuroinformatics Node (G-Node)
 #
 # All rights reserved.
 #
@@ -260,6 +260,8 @@ def position(self):
 
     @position.setter
     def position(self, pos):
+        if pos is not None and not hasattr(pos, "__getitem__"):
+            pos = [pos]
         if pos is None or len(pos) == 0:
             if self._h5group.has_data("position"):
                 del self._h5group["position"]
@@ -281,6 +283,8 @@ def extent(self):
 
     @extent.setter
     def extent(self, ext):
+        if ext is not None and not hasattr(ext, "__getitem__"):
+            ext = [ext]
         if ext is None or len(ext) == 0:
             if self._h5group.has_data("extent"):
                 del self._h5group["extent"]
@@ -313,6 +317,8 @@ def tagged_data(self, refidx, stop_rule=SliceMode.Exclusive):
                 "do not match ", extent)
 
         slices = self._calc_data_slices(ref, self.position, self.extent, stop_rule)
+        if not all(slices):
+            return DataView(ref, slices)
         if not self._slices_in_data(ref, slices):
             raise OutOfBounds("References data slice out of the extent of the "
                               "DataArray!")

nixio/test/test_data_array.py

@@ -13,6 +13,7 @@
 import unittest
 import numpy as np
 import nixio as nix
+from nixio.data_array import DataSliceMode
 from nixio.exceptions import IncompatibleDimensions
 from .tmp import TempDir
 
@@ -444,6 +445,21 @@ def test_get_slice(self):
         with self.assertRaises(IncompatibleDimensions):
             da3d.get_slice((0, 0, 0), (3, 9, 40, 1))
 
+        dslice = da2d.get_slice([20, 1], [10, 1], DataSliceMode.Data)
+        self.assertFalse(dslice.valid)
+
+        time_vector = np.arange(0.0, 10., 0.001)
+        indices = np.random.rand(len(time_vector))
+
+        event_data = time_vector[(indices < 0.1)]
+        event_data = event_data[(event_data < 4) | (event_data > 7)]
+
+        event_da = self.block.create_data_array("event_data", "nix.events", data=event_data, unit="s")
+        event_da.append_range_dimension_using_self()
+        selection = event_da.get_slice([4.5], [1.0], nix.DataSliceMode.Data)
+        self.assertFalse(selection.valid)
+        np.testing.assert_almost_equal(np.array([]), selection[:])
+
     def test_dim_one_based(self):
         self.array.append_set_dimension()
         self.array.append_range_dimension(range(10))

nixio/test/test_tag.py

@@ -579,26 +579,52 @@ def test_tagged_range_dim(self):
                 # +0.1 should round up (ceil) the start position
                 # +0.1 * 2 should round down (floor) the stop position and works the same for both inclusive and
                 # exclusive
-                tag.position = [pos+0.1]
-                tag.extent = [ext+0.1]
-                start = pos+1
-                stop = pos+ext+1
+                tag.position = [pos + 0.1]
+                tag.extent = [ext + 0.1]
+                start = pos + 1
+                stop = pos + ext + 1
                 np.testing.assert_array_almost_equal(tag.tagged_data(0), da[start:stop])
                 np.testing.assert_array_almost_equal(tag.tagged_data(0, nix.SliceMode.Exclusive), da[start:stop])
                 np.testing.assert_array_almost_equal(tag.tagged_data(0, nix.SliceMode.Inclusive), da[start:stop])
 
-                if pos+ext+2 < len(da):
+                if pos + ext + 2 < len(da):
                     # +0.9 should round up (ceil) the start position
                     # +0.9 * 2 should round down (floor) the stop position and works the same for both inclusive and
                     # exclusive
-                    tag.position = [pos+0.9]
-                    tag.extent = [ext+0.9]
-                    start = pos+1
-                    stop = pos+ext+2
+                    tag.position = [pos + 0.9]
+                    tag.extent = [ext + 0.9]
+                    start = pos + 1
+                    stop = pos + ext + 2
                     np.testing.assert_array_almost_equal(tag.tagged_data(0), da[start:stop])
                     np.testing.assert_array_almost_equal(tag.tagged_data(0, nix.SliceMode.Exclusive), da[start:stop])
                     np.testing.assert_array_almost_equal(tag.tagged_data(0, nix.SliceMode.Inclusive), da[start:stop])
 
+        time_vector = np.arange(0.0, 10., 0.001)
+        indices = np.random.rand(len(time_vector))
+        event_data = time_vector[(indices < 0.1)]
+        event_data = event_data[(event_data < 4) | (event_data > 7)]
+
+        event_da = self.block.create_data_array("event_data", "nix.events", data=event_data, unit="s")
+        event_da.append_range_dimension_using_self()
+
+        tt = self.block.create_tag("no_event_segment", "nix.segment", 4.5)
+        tt.extent = 1.0
+        tt.references.append(event_da)
+        sl = tt.tagged_data(0)
+        self.assertFalse(sl.valid)
+
+        tt2 = self.block.create_tag("beyond data", "nix.segment", 12.0)
+        tt2.extent = 3.0
+        tt2.references.append(event_da)
+        sl = tt2.tagged_data(0)
+        self.assertFalse(sl.valid)
+
+        tt3 = self.block.create_tag("reachingbeyonddata", "nix.segment", 8.5)
+        tt3.extent = [3.0]
+        tt3.references.append(event_da)
+        sl = tt3.tagged_data(0)
+        self.assertTrue(sl.valid)
+
     def test_tagged_sampled_dim(self):
         """
         Simple test where the slice can be calculated directly from the position and extent and compared to the original