diff --git a/.github/workflows/publish-to-pypi-test.yml b/.github/workflows/publish-to-pypi-test.yml
index 5a8140e59..71e7b9409 100644
--- a/.github/workflows/publish-to-pypi-test.yml
+++ b/.github/workflows/publish-to-pypi-test.yml
@@ -20,14 +20,19 @@ jobs:
         python -m pip install --upgrade pip
         pip install setuptools wheel twine build
         pip install .
+    - name: Get the tag version
+      id: get-version
+      run: |
+        echo ${GITHUB_REF#refs/tags/}
+        echo "TAG::${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
     - name: Test version/tag correspondence
       id: version-check
       run: |
         neo_version=$(python -c "import neo; print(neo.__version__)")
+        tag_version=${{ steps.get-version.outputs.TAG }}
         echo $neo_version
-        TAG=${{ github.event.release.tag_name }}
-        echo $TAG
-        if [[ $TAG == $neo_version ]]; then
+        echo $tag_version
+        if [[ $tag_version == $neo_version ]]; then
             echo "VERSION_TAG_MATCH=true" >> $GITHUB_OUTPUT
             echo "Version matches tag, proceeding with release to Test PyPI"
         else
diff --git a/neo/core/baseneo.py b/neo/core/baseneo.py
index 40e736567..060a8b6c5 100644
--- a/neo/core/baseneo.py
+++ b/neo/core/baseneo.py
@@ -154,7 +154,11 @@ def _container_name(class_name):
     referenced by `block.segments`. The attribute name `segments` is
     obtained by calling `_container_name_plural("Segment")`.
     """
-    return _reference_name(class_name) + 's'
+    if "RegionOfInterest" in class_name:
+        # this is a hack, pending a more principled way to handle this
+        return "regionsofinterest"
+    else:
+        return _reference_name(class_name) + 's'
 
 
 class BaseNeo:
diff --git a/neo/core/block.py b/neo/core/block.py
index baa6f64f4..93a0f4b1c 100644
--- a/neo/core/block.py
+++ b/neo/core/block.py
@@ -12,7 +12,6 @@
 from neo.core.container import Container, unique_objs
 from neo.core.group import Group
 from neo.core.objectlist import ObjectList
-from neo.core.regionofinterest import RegionOfInterest
 from neo.core.segment import Segment
 
 
@@ -91,7 +90,6 @@ def __init__(self, name=None, description=None, file_origin=None,
         self.index = index
         self._segments = ObjectList(Segment, parent=self)
         self._groups = ObjectList(Group, parent=self)
-        self._regionsofinterest = ObjectList(RegionOfInterest, parent=self)
 
     segments = property(
         fget=lambda self: self._get_object_list("_segments"),
@@ -105,12 +103,6 @@ def __init__(self, name=None, description=None, file_origin=None,
         doc="list of Groups contained in this block"
     )
 
-    regionsofinterest = property(
-        fget=lambda self: self._get_object_list("_regionsofinterest"),
-        fset=lambda self, value: self._set_object_list("_regionsofinterest", value),
-        doc="list of RegionOfInterest objects contained in this block"
-    )
-
     @property
     def data_children_recur(self):
         '''
diff --git a/neo/core/group.py b/neo/core/group.py
index f4a34273e..06d3304d8 100644
--- a/neo/core/group.py
+++ b/neo/core/group.py
@@ -18,6 +18,7 @@
 from neo.core.segment import Segment
 from neo.core.spiketrainlist import SpikeTrainList
 from neo.core.view import ChannelView
+from neo.core.regionofinterest import RegionOfInterest
 
 
 class Group(Container):
@@ -49,7 +50,8 @@ class Group(Container):
     """
     _data_child_objects = (
         'AnalogSignal', 'IrregularlySampledSignal', 'SpikeTrain',
-        'Event', 'Epoch', 'ChannelView', 'ImageSequence'
+        'Event', 'Epoch', 'ChannelView', 'ImageSequence', 'CircularRegionOfInterest',
+        'RectangularRegionOfInterest', 'PolygonRegionOfInterest'
     )
     _container_child_objects = ('Group',)
     _parent_objects = ('Block',)
@@ -69,6 +71,7 @@ def __init__(self, objects=None, name=None, description=None, file_origin=None,
         self._epochs = ObjectList(Epoch)
         self._channelviews = ObjectList(ChannelView)
         self._imagesequences = ObjectList(ImageSequence)
+        self._regionsofinterest = ObjectList(RegionOfInterest)
         self._segments = ObjectList(Segment)  # to remove?
         self._groups = ObjectList(Group)
 
@@ -119,6 +122,12 @@ def __init__(self, objects=None, name=None, description=None, file_origin=None,
         doc="list of ImageSequences contained in this group"
     )
 
+    regionsofinterest = property(
+        fget=lambda self: self._get_object_list("_regionsofinterest"),
+        fset=lambda self, value: self._set_object_list("_regionsofinterest", value),
+        doc="list of RegionOfInterest objects contained in this group"
+    )
+
     spiketrains = property(
         fget=lambda self: self._get_object_list("_spiketrains"),
         fset=lambda self, value: self._set_object_list("_spiketrains", value),
diff --git a/neo/core/imagesequence.py b/neo/core/imagesequence.py
index 2a84e8d02..3a877ba9f 100644
--- a/neo/core/imagesequence.py
+++ b/neo/core/imagesequence.py
@@ -97,7 +97,7 @@ class ImageSequence(BaseSignal):
     )
     _recommended_attrs = BaseNeo._recommended_attrs
 
-    def __new__(cls, image_data, units=None, dtype=None, copy=True, t_start=0 * pq.s,
+    def __new__(cls, image_data, units=pq.dimensionless, dtype=None, copy=True, t_start=0 * pq.s,
                 spatial_scale=None, frame_duration=None,
                 sampling_rate=None, name=None, description=None, file_origin=None,
                 **annotations):
@@ -127,7 +127,7 @@ def __new__(cls, image_data, units=None, dtype=None, copy=True, t_start=0 * pq.s
 
         return obj
 
-    def __init__(self, image_data, units=None, dtype=None, copy=True, t_start=0 * pq.s,
+    def __init__(self, image_data, units=pq.dimensionless, dtype=None, copy=True, t_start=0 * pq.s,
                  spatial_scale=None, frame_duration=None,
                  sampling_rate=None, name=None, description=None, file_origin=None,
                  **annotations):
@@ -142,7 +142,7 @@ def __array_finalize__spec(self, obj):
 
         self.sampling_rate = getattr(obj, "sampling_rate", None)
         self.spatial_scale = getattr(obj, "spatial_scale", None)
-        self.units = getattr(obj, "units", None)
+        self.units = getattr(obj, "units", pq.dimensionless)
         self._t_start = getattr(obj, "_t_start", 0 * pq.s)
 
         return obj
diff --git a/neo/core/regionofinterest.py b/neo/core/regionofinterest.py
index cdf463653..458fb7067 100644
--- a/neo/core/regionofinterest.py
+++ b/neo/core/regionofinterest.py
@@ -1,11 +1,32 @@
 from math import floor, ceil
 
 from neo.core.baseneo import BaseNeo
+from neo.core.imagesequence import ImageSequence
 
 
 class RegionOfInterest(BaseNeo):
     """Abstract base class"""
-    pass
+
+    _parent_objects = ('Group',)
+    _parent_attrs = ('group',)
+    _necessary_attrs = (
+        ('obj', ('ImageSequence', ), 1),
+    )
+
+    def __init__(self, image_sequence, name=None, description=None, file_origin=None, **annotations):
+        super().__init__(name=name, description=description,
+                        file_origin=file_origin, **annotations)
+
+        if not (isinstance(image_sequence, ImageSequence) or (
+                hasattr(image_sequence, "proxy_for") and issubclass(image_sequence.proxy_for, ImageSequence))):
+            raise ValueError("Can only take a RegionOfInterest of an ImageSequence")
+        self.image_sequence = image_sequence
+
+    def resolve(self):
+        """
+        Return a signal from within this region of the underlying ImageSequence.
+        """
+        return self.image_sequence.signal_from_region(self)
 
 
 class CircularRegionOfInterest(RegionOfInterest):
@@ -23,8 +44,9 @@ class CircularRegionOfInterest(RegionOfInterest):
             Radius of the ROI in pixels
     """
 
-    def __init__(self, x, y, radius):
-
+    def __init__(self, image_sequence, x, y, radius, name=None, description=None,
+                 file_origin=None, **annotations):
+        super().__init__(image_sequence, name, description, file_origin, **annotations)
         self.y = y
         self.x = x
         self.radius = radius
@@ -72,7 +94,9 @@ class RectangularRegionOfInterest(RegionOfInterest):
             Height (y-direction) of the ROI in pixels
     """
 
-    def __init__(self, x, y, width, height):
+    def __init__(self, image_sequence, x, y, width, height, name=None, description=None,
+                 file_origin=None, **annotations):
+        super().__init__(image_sequence, name, description, file_origin, **annotations)
         self.x = x
         self.y = y
         self.width = width
@@ -115,7 +139,9 @@ class PolygonRegionOfInterest(RegionOfInterest):
             of the vertices of the polygon
     """
 
-    def __init__(self, *vertices):
+    def __init__(self, image_sequence, *vertices, name=None, description=None,
+                 file_origin=None, **annotations):
+        super().__init__(image_sequence, name, description, file_origin, **annotations)
         self.vertices = vertices
 
     def polygon_ray_casting(self, bounding_points, bounding_box_positions):
diff --git a/neo/io/baseio.py b/neo/io/baseio.py
index acce7de6f..2ce5b07bf 100644
--- a/neo/io/baseio.py
+++ b/neo/io/baseio.py
@@ -10,6 +10,8 @@
 
 If you want a model for developing a new IO start from exampleIO.
 """
+from __future__ import annotations
+from pathlib import Path
 
 try:
     from collections.abc import Sequence
@@ -96,7 +98,7 @@ class BaseIO:
 
     mode = 'file'  # or 'fake' or 'dir' or 'database'
 
-    def __init__(self, filename=None, **kargs):
+    def __init__(self, filename: str | Path = None, **kargs):
         self.filename = str(filename)
         # create a logger for the IO class
         fullname = self.__class__.__module__ + '.' + self.__class__.__name__
@@ -111,7 +113,7 @@ def __init__(self, filename=None, **kargs):
             corelogger.addHandler(logging_handler)
 
     ######## General read/write methods #######################
-    def read(self, lazy=False, **kargs):
+    def read(self, lazy: bool = False, **kargs):
         """
         Return all data from the file as a list of Blocks
         """
diff --git a/neo/rawio/baserawio.py b/neo/rawio/baserawio.py
index c9646bbd8..08fb073b6 100644
--- a/neo/rawio/baserawio.py
+++ b/neo/rawio/baserawio.py
@@ -67,6 +67,7 @@
 constructions of a RawIO for a given set of data.
 
 """
+from __future__ import annotations
 
 import logging
 import numpy as np
@@ -133,7 +134,7 @@ class BaseRawIO:
 
     rawmode = None  # one key from possible_raw_modes
 
-    def __init__(self, use_cache=False, cache_path='same_as_resource', **kargs):
+    def __init__(self, use_cache: bool = False, cache_path: str = 'same_as_resource', **kargs):
         """
         :TODO: Why multi-file would have a single filename is confusing here - shouldn't
         the name of this argument be filenames_list or filenames_base or similar?
@@ -369,7 +370,7 @@ def block_count(self):
         """return number of blocks"""
         return self.header['nb_block']
 
-    def segment_count(self, block_index):
+    def segment_count(self, block_index: int):
         """return number of segments for a given block"""
         return self.header['nb_segment'][block_index]
 
@@ -379,7 +380,7 @@ def signal_streams_count(self):
         """
         return len(self.header['signal_streams'])
 
-    def signal_channels_count(self, stream_index):
+    def signal_channels_count(self, stream_index: int):
         """Return the number of signal channels for a given stream.
         This number is the same for all Blocks and Segments.
         """
@@ -400,7 +401,7 @@ def event_channels_count(self):
         """
         return len(self.header['event_channels'])
 
-    def segment_t_start(self, block_index, seg_index):
+    def segment_t_start(self, block_index: int, seg_index: int):
         """Global t_start of a Segment in s. Shared by all objects except
         for AnalogSignal.
         """
@@ -445,7 +446,7 @@ def _check_stream_signal_channel_characteristics(self):
 
         self._several_channel_groups = signal_streams.size > 1
 
-    def channel_name_to_index(self, stream_index, channel_names):
+    def channel_name_to_index(self, stream_index: int, channel_names: list[str]):
         """
         Inside a stream, transform channel_names to channel_indexes.
         Based on self.header['signal_channels']
@@ -459,7 +460,7 @@ def channel_name_to_index(self, stream_index, channel_names):
         channel_indexes = np.array([chan_names.index(name) for name in channel_names])
         return channel_indexes
 
-    def channel_id_to_index(self, stream_index, channel_ids):
+    def channel_id_to_index(self, stream_index: int, channel_ids: list[str]):
         """
         Inside a stream, transform channel_ids to channel_indexes.
         Based on self.header['signal_channels']
@@ -473,7 +474,11 @@ def channel_id_to_index(self, stream_index, channel_ids):
         channel_indexes = np.array([chan_ids.index(chan_id) for chan_id in channel_ids])
         return channel_indexes
 
-    def _get_channel_indexes(self, stream_index, channel_indexes, channel_names, channel_ids):
+    def _get_channel_indexes(self,
+                             stream_index: int,
+                             channel_indexes: list[int] | None,
+                             channel_names: list[str] | None,
+                             channel_ids: list[str] | None):
         """
         Select channel_indexes for a stream based on channel_indexes/channel_names/channel_ids
         depending which is not None.
@@ -484,7 +489,7 @@ def _get_channel_indexes(self, stream_index, channel_indexes, channel_names, cha
             channel_indexes = self.channel_id_to_index(stream_index, channel_ids)
         return channel_indexes
 
-    def _get_stream_index_from_arg(self, stream_index_arg):
+    def _get_stream_index_from_arg(self, stream_index_arg: int | None):
         if stream_index_arg is None:
             assert self.header['signal_streams'].size == 1
             stream_index = 0
@@ -493,7 +498,7 @@ def _get_stream_index_from_arg(self, stream_index_arg):
             stream_index = stream_index_arg
         return stream_index
 
-    def get_signal_size(self, block_index, seg_index, stream_index=None):
+    def get_signal_size(self, block_index: int, seg_index: int, stream_index: int | None = None):
         """
         Retrieve the length of a single section of the channels in a stream.
         :param block_index:
@@ -504,7 +509,10 @@ def get_signal_size(self, block_index, seg_index, stream_index=None):
         stream_index = self._get_stream_index_from_arg(stream_index)
         return self._get_signal_size(block_index, seg_index, stream_index)
 
-    def get_signal_t_start(self, block_index, seg_index, stream_index=None):
+    def get_signal_t_start(self,
+                           block_index: int,
+                           seg_index: int,
+                           stream_index: int | None = None):
         """
         Retrieve the t_start of a single section of the channels in a stream.
         :param block_index:
@@ -515,7 +523,7 @@ def get_signal_t_start(self, block_index, seg_index, stream_index=None):
         stream_index = self._get_stream_index_from_arg(stream_index)
         return self._get_signal_t_start(block_index, seg_index, stream_index)
 
-    def get_signal_sampling_rate(self, stream_index=None):
+    def get_signal_sampling_rate(self, stream_index: int | None = None):
         """
         Retrieve sampling rate for a stream and all channels in that stream.
         :param stream_index:
@@ -528,9 +536,16 @@ def get_signal_sampling_rate(self, stream_index=None):
         sr = signal_channels[0]['sampling_rate']
         return float(sr)
 
-    def get_analogsignal_chunk(self, block_index=0, seg_index=0, i_start=None, i_stop=None,
-                               stream_index=None, channel_indexes=None, channel_names=None,
-                               channel_ids=None, prefer_slice=False):
+    def get_analogsignal_chunk(self,
+                               block_index: int = 0,
+                               seg_index: int = 0,
+                               i_start: int | None = None,
+                               i_stop: int | None = None,
+                               stream_index: int | None = None,
+                               channel_indexes: list[int] | None = None,
+                               channel_names: list[str] | None = None,
+                               channel_ids: list[str] | None = None,
+                               prefer_slice: bool = False):
         """
         Return a chunk of raw signal as a Numpy array. columns correspond to samples from a
         section of a single channel of recording. The channels are chosen either by channel_names,
@@ -587,8 +602,13 @@ def get_analogsignal_chunk(self, block_index=0, seg_index=0, i_start=None, i_sto
 
         return raw_chunk
 
-    def rescale_signal_raw_to_float(self, raw_signal, dtype='float32', stream_index=None,
-                                    channel_indexes=None, channel_names=None, channel_ids=None):
+    def rescale_signal_raw_to_float(self,
+                                    raw_signal: np.ndarray,
+                                    dtype: np.dtype = 'float32',
+                                    stream_index: int | None = None,
+                                    channel_indexes: list[int] | None = None,
+                                    channel_names: list[str] | None = None,
+                                    channel_ids: list[str] | None = None):
         """
         Rescale a chunk of raw signals which are provided as a Numpy array. These are normally
         returned by a call to get_analogsignal_chunk. The channels are specified either by
@@ -627,11 +647,15 @@ def rescale_signal_raw_to_float(self, raw_signal, dtype='float32', stream_index=
         return float_signal
 
     # spiketrain and unit zone
-    def spike_count(self, block_index=0, seg_index=0, spike_channel_index=0):
+    def spike_count(self, block_index: int = 0, seg_index: int = 0, spike_channel_index: int = 0):
         return self._spike_count(block_index, seg_index, spike_channel_index)
 
-    def get_spike_timestamps(self, block_index=0, seg_index=0, spike_channel_index=0,
-                             t_start=None, t_stop=None):
+    def get_spike_timestamps(self,
+                             block_index: int = 0,
+                             seg_index: int = 0,
+                             spike_channel_index: int = 0,
+                             t_start: float | None = None,
+                             t_stop: float | None = None):
         """
         The timestamp datatype is as close to the format itself. Sometimes float/int32/int64.
         Sometimes it is the index on the signal but not always.
@@ -643,21 +667,25 @@ def get_spike_timestamps(self, block_index=0, seg_index=0, spike_channel_index=0
                                                spike_channel_index, t_start, t_stop)
         return timestamp
 
-    def rescale_spike_timestamp(self, spike_timestamps, dtype='float64'):
+    def rescale_spike_timestamp(self, spike_timestamps: np.ndarray, dtype: np.dtype = 'float64'):
         """
         Rescale spike timestamps to seconds.
         """
         return self._rescale_spike_timestamp(spike_timestamps, dtype)
 
     # spiketrain waveform zone
-    def get_spike_raw_waveforms(self, block_index=0, seg_index=0, spike_channel_index=0,
-                                t_start=None, t_stop=None):
+    def get_spike_raw_waveforms(self,
+                                block_index: int = 0,
+                                seg_index: int = 0,
+                                spike_channel_index: int = 0,
+                                t_start: float | None = None,
+                                t_stop: float | None = None):
         wf = self._get_spike_raw_waveforms(block_index, seg_index,
                                            spike_channel_index, t_start, t_stop)
         return wf
 
-    def rescale_waveforms_to_float(self, raw_waveforms, dtype='float32',
-                                   spike_channel_index=0):
+    def rescale_waveforms_to_float(self, raw_waveforms: np.ndarray, dtype: np.dtype = 'float32',
+                                   spike_channel_index: int = 0):
         wf_gain = self.header['spike_channels']['wf_gain'][spike_channel_index]
         wf_offset = self.header['spike_channels']['wf_offset'][spike_channel_index]
 
@@ -671,11 +699,15 @@ def rescale_waveforms_to_float(self, raw_waveforms, dtype='float32',
         return float_waveforms
 
     # event and epoch zone
-    def event_count(self, block_index=0, seg_index=0, event_channel_index=0):
+    def event_count(self, block_index: int = 0, seg_index: int = 0, event_channel_index: int = 0):
         return self._event_count(block_index, seg_index, event_channel_index)
 
-    def get_event_timestamps(self, block_index=0, seg_index=0, event_channel_index=0,
-                             t_start=None, t_stop=None):
+    def get_event_timestamps(self,
+                             block_index: int = 0,
+                             seg_index: int = 0,
+                             event_channel_index: int = 0,
+                             t_start: float | None = None,
+                             t_stop: float | None = None):
         """
         The timestamp datatype is as close to the format itself. Sometimes float/int32/int64.
         Sometimes it is the index on the signal but not always.
@@ -693,21 +725,23 @@ def get_event_timestamps(self, block_index=0, seg_index=0, event_channel_index=0
             block_index, seg_index, event_channel_index, t_start, t_stop)
         return timestamp, durations, labels
 
-    def rescale_event_timestamp(self, event_timestamps, dtype='float64',
-                    event_channel_index=0):
+    def rescale_event_timestamp(self,
+                                event_timestamps: np.ndarray,
+                                dtype: np.dtype = 'float64',
+                                event_channel_index: int = 0):
         """
         Rescale event timestamps to seconds.
         """
         return self._rescale_event_timestamp(event_timestamps, dtype, event_channel_index)
 
-    def rescale_epoch_duration(self, raw_duration, dtype='float64',
-                    event_channel_index=0):
+    def rescale_epoch_duration(self, raw_duration: np.ndarray, dtype: np.dtype = 'float64',
+                    event_channel_index: int = 0):
         """
         Rescale epoch raw duration to seconds.
         """
         return self._rescale_epoch_duration(raw_duration, dtype, event_channel_index)
 
-    def setup_cache(self, cache_path, **init_kargs):
+    def setup_cache(self, cache_path: 'home' | 'same_as_resource', **init_kargs):
         try:
             import joblib
         except ImportError:
@@ -735,7 +769,7 @@ def setup_cache(self, cache_path, **init_kargs):
             dirname = os.path.dirname(resource_name)
         else:
             assert os.path.exists(cache_path), \
-                'cache_path do not exists use "home" or "same_as_resource" to make this auto'
+                'cache_path does not exists use "home" or "same_as_resource" to make this auto'
 
         # the hash of the resource (dir of file) is done with filename+datetime
         # TODO make something more sophisticated when rawmode='one-dir' that use all
@@ -776,15 +810,15 @@ def _parse_header(self):
     def _source_name(self):
         raise (NotImplementedError)
 
-    def _segment_t_start(self, block_index, seg_index):
+    def _segment_t_start(self, block_index: int, seg_index: int):
         raise (NotImplementedError)
 
-    def _segment_t_stop(self, block_index, seg_index):
+    def _segment_t_stop(self, block_index: int, seg_index: int):
         raise (NotImplementedError)
 
     ###
     # signal and channel zone
-    def _get_signal_size(self, block_index, seg_index, stream_index):
+    def _get_signal_size(self, block_index: int, seg_index: int, stream_index: int):
         """
         Return the size of a set of AnalogSignals indexed by channel_indexes.
 
@@ -792,7 +826,7 @@ def _get_signal_size(self, block_index, seg_index, stream_index):
         """
         raise (NotImplementedError)
 
-    def _get_signal_t_start(self, block_index, seg_index, stream_index):
+    def _get_signal_t_start(self, block_index: int, seg_index: int, stream_index: int):
         """
         Return the t_start of a set of AnalogSignals indexed by channel_indexes.
 
@@ -800,8 +834,13 @@ def _get_signal_t_start(self, block_index, seg_index, stream_index):
         """
         raise (NotImplementedError)
 
-    def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop,
-                                stream_index, channel_indexes):
+    def _get_analogsignal_chunk(self,
+                                block_index: int,
+                                seg_index: int,
+                                i_start: int | None,
+                                i_stop: int | None,
+                                stream_index: int,
+                                channel_indexes: list[int] | None):
         """
         Return the samples from a set of AnalogSignals indexed
         by stream_index and channel_indexes (local index inner stream).
@@ -815,38 +854,51 @@ def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop,
 
     ###
     # spiketrain and unit zone
-    def _spike_count(self, block_index, seg_index, spike_channel_index):
+    def _spike_count(self, block_index: int, seg_index: int, spike_channel_index: int):
         raise (NotImplementedError)
 
-    def _get_spike_timestamps(self, block_index, seg_index,
-                              spike_channel_index, t_start, t_stop):
+    def _get_spike_timestamps(self,
+                              block_index: int,
+                              seg_index: int,
+                              spike_channel_index: int,
+                              t_start: float | None,
+                              t_stop: float | None):
         raise (NotImplementedError)
 
-    def _rescale_spike_timestamp(self, spike_timestamps, dtype):
+    def _rescale_spike_timestamp(self, spike_timestamps: np.ndarray, dtype: np.dtype):
         raise (NotImplementedError)
 
     ###
     # spike waveforms zone
-    def _get_spike_raw_waveforms(self, block_index, seg_index,
-                                 spike_channel_index, t_start, t_stop):
+    def _get_spike_raw_waveforms(self,
+                                 block_index: int,
+                                 seg_index: int,
+                                 spike_channel_index: int,
+                                 t_start: float | None,
+                                 t_stop: float | None):
         raise (NotImplementedError)
 
     ###
     # event and epoch zone
-    def _event_count(self, block_index, seg_index, event_channel_index):
+    def _event_count(self, block_index: int, seg_index: int, event_channel_index: int):
         raise (NotImplementedError)
 
-    def _get_event_timestamps(self, block_index, seg_index, event_channel_index, t_start, t_stop):
+    def _get_event_timestamps(self,
+                              block_index: int,
+                              seg_index: int,
+                              event_channel_index: int,
+                              t_start: float | None,
+                              t_stop: float | None):
         raise (NotImplementedError)
 
-    def _rescale_event_timestamp(self, event_timestamps, dtype):
+    def _rescale_event_timestamp(self, event_timestamps: np.ndarray, dtype: np.dtype):
         raise (NotImplementedError)
 
-    def _rescale_epoch_duration(self, raw_duration, dtype):
+    def _rescale_epoch_duration(self, raw_duration: np.ndarray, dtype: np.dtype):
         raise (NotImplementedError)
 
 
-def pprint_vector(vector, lim=8):
+def pprint_vector(vector, lim: int = 8):
     vector = np.asarray(vector)
     assert vector.ndim == 1
     if len(vector) > lim:
diff --git a/neo/rawio/examplerawio.py b/neo/rawio/examplerawio.py
index 26b4572b7..27710b6fb 100644
--- a/neo/rawio/examplerawio.py
+++ b/neo/rawio/examplerawio.py
@@ -34,11 +34,14 @@
     * copy/paste from neo/test/iotest/test_exampleio.py
 
 """
+from __future__ import annotations
+
+import numpy as np
+from pathlib import Path
 
 from .baserawio import (BaseRawIO, _signal_channel_dtype, _signal_stream_dtype,
                 _spike_channel_dtype, _event_channel_dtype)
 
-import numpy as np
 
 
 class ExampleRawIO(BaseRawIO):
@@ -82,7 +85,7 @@ class ExampleRawIO(BaseRawIO):
     extensions = ['fake']
     rawmode = 'one-file'
 
-    def __init__(self, filename=''):
+    def __init__(self, filename: str | Path = ''):
         BaseRawIO.__init__(self)
         # note that this filename is ued in self._source_name
         self.filename = filename
@@ -228,19 +231,19 @@ def _parse_header(self):
                     elif c == 1:
                         event_an['nickname'] = 'MrEpoch 1'
 
-    def _segment_t_start(self, block_index, seg_index):
+    def _segment_t_start(self, block_index: int, seg_index: int):
         # this must return a float scaled in seconds
         # this t_start will be shared by all objects in the segment
         # except AnalogSignal
         all_starts = [[0., 15.], [0., 20., 60.]]
         return all_starts[block_index][seg_index]
 
-    def _segment_t_stop(self, block_index, seg_index):
+    def _segment_t_stop(self, block_index: int, seg_index: int):
         # this must return a float scaled in seconds
         all_stops = [[10., 25.], [10., 30., 70.]]
         return all_stops[block_index][seg_index]
 
-    def _get_signal_size(self, block_index, seg_index, stream_index):
+    def _get_signal_size(self, block_index: int, seg_index: int, stream_index: int):
         # We generate fake data in which the two stream signals have the same shape
         # across all segments (10.0 seconds)
         # This is not the case for real data, instead you should return the signal
@@ -251,7 +254,7 @@ def _get_signal_size(self, block_index, seg_index, stream_index):
         # except for the case of several sampling rates.
         return 100000
 
-    def _get_signal_t_start(self, block_index, seg_index, stream_index):
+    def _get_signal_t_start(self, block_index: int, seg_index: int, stream_index: int):
         # This give the t_start of a signal.
         # Very often this is equal to _segment_t_start but not
         # always.
@@ -264,8 +267,13 @@ def _get_signal_t_start(self, block_index, seg_index, stream_index):
         # this is not always the case
         return self._segment_t_start(block_index, seg_index)
 
-    def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop,
-                                stream_index, channel_indexes):
+    def _get_analogsignal_chunk(self,
+                                block_index: int,
+                                seg_index: int,
+                                i_start: int | None,
+                                i_stop: int | None,
+                                stream_index: int,
+                                channel_indexes: np.ndarray | list | slice | None):
         # this must return a signal chunk in a signal stream
         # limited with i_start/i_stop (can be None)
         # channel_indexes can be None (=all channel in the stream) or a list or numpy.array
@@ -305,14 +313,19 @@ def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop,
         raw_signals = np.zeros((i_stop - i_start, nb_chan), dtype='int16')
         return raw_signals
 
-    def _spike_count(self, block_index, seg_index, spike_channel_index):
+    def _spike_count(self, block_index: int, seg_index: int, spike_channel_index: int):
         # Must return the nb of spikes for given (block_index, seg_index, spike_channel_index)
         # we are lucky:  our units have all the same nb of spikes!!
         # it is not always the case
         nb_spikes = 20
         return nb_spikes
 
-    def _get_spike_timestamps(self, block_index, seg_index, spike_channel_index, t_start, t_stop):
+    def _get_spike_timestamps(self,
+                              block_index: int,
+                              seg_index: int,
+                              spike_channel_index: int,
+                              t_start: float | None,
+                              t_stop: float | None):
         # In our IO, timestamp are internally coded 'int64' and they
         # represent the index of the signals 10kHz
         # we are lucky: spikes have the same discharge in all segments!!
@@ -333,15 +346,19 @@ def _get_spike_timestamps(self, block_index, seg_index, spike_channel_index, t_s
 
         return spike_timestamps
 
-    def _rescale_spike_timestamp(self, spike_timestamps, dtype):
+    def _rescale_spike_timestamp(self, spike_timestamps: np.ndarray, dtype: np.dtype):
         # must rescale to seconds, a particular spike_timestamps
         # with a fixed dtype so the user can choose the precision they want.
         spike_times = spike_timestamps.astype(dtype)
         spike_times /= 10000.  # because 10kHz
         return spike_times
 
-    def _get_spike_raw_waveforms(self, block_index, seg_index, spike_channel_index,
-                                 t_start, t_stop):
+    def _get_spike_raw_waveforms(self,
+                                 block_index: int,
+                                 seg_index: int,
+                                 spike_channel_index: int,
+                                 t_start: float | None,
+                                 t_stop: float | None):
         # this must return a 3D numpy array (nb_spike, nb_channel, nb_sample)
         # in the original dtype
         # this must be as fast as possible.
@@ -367,7 +384,7 @@ def _get_spike_raw_waveforms(self, block_index, seg_index, spike_channel_index,
         waveforms = waveforms.reshape(nb_spike, 1, 50)
         return waveforms
 
-    def _event_count(self, block_index, seg_index, event_channel_index):
+    def _event_count(self, block_index: int, seg_index: int, event_channel_index: int):
         # event and spike are very similar
         # we have 2 event channels
         if event_channel_index == 0:
@@ -377,7 +394,12 @@ def _event_count(self, block_index, seg_index, event_channel_index):
             # epoch channel
             return 10
 
-    def _get_event_timestamps(self, block_index, seg_index, event_channel_index, t_start, t_stop):
+    def _get_event_timestamps(self,
+                              block_index: int,
+                              seg_index: int,
+                              event_channel_index: int,
+                              t_start: float | None,
+                              t_stop: float | None):
         # the main difference between spike channel and event channel
         # is that for event channels we have 3D numpy array (timestamp, durations, labels) where
         # durations must be None for 'event'
@@ -408,7 +430,10 @@ def _get_event_timestamps(self, block_index, seg_index, event_channel_index, t_s
 
         return timestamp, durations, labels
 
-    def _rescale_event_timestamp(self, event_timestamps, dtype, event_channel_index):
+    def _rescale_event_timestamp(self,
+                                 event_timestamps: np.ndarray,
+                                 dtype: np.dtype,
+                                 event_channel_index: int):
         # must rescale to seconds for a particular event_timestamps
         # with a fixed dtype so the user can choose the precision they want.
 
@@ -416,7 +441,10 @@ def _rescale_event_timestamp(self, event_timestamps, dtype, event_channel_index)
         event_times = event_timestamps.astype(dtype)
         return event_times
 
-    def _rescale_epoch_duration(self, raw_duration, dtype, event_channel_index):
+    def _rescale_epoch_duration(self,
+                                raw_duration: np.ndarray,
+                                dtype: np.dtype,
+                                event_channel_index: int):
         # really easy here because in our case it is already in seconds
         durations = raw_duration.astype(dtype)
         return durations
diff --git a/neo/rawio/neuralynxrawio/ncssections.py b/neo/rawio/neuralynxrawio/ncssections.py
index 6f8eacad8..b372478c4 100644
--- a/neo/rawio/neuralynxrawio/ncssections.py
+++ b/neo/rawio/neuralynxrawio/ncssections.py
@@ -438,7 +438,7 @@ def build_for_ncs_file(ncsMemMap, nlxHdr):
 
         # digital lynx style with fractional frequency and micros per samp determined from
         # block times
-        elif acqType == "DIGITALLYNX" or acqType == "DIGITALLYNXSX" or acqType == 'CHEETAH64' or acqType == 'RAWDATAFILE':
+        elif acqType in ["DIGITALLYNX", "DIGITALLYNXSX", 'CHEETAH64', 'CHEETAH560', 'RAWDATAFILE']:
             nomFreq = nlxHdr['sampling_rate']
             nb = NcsSectionsFactory._buildForMaxGap(ncsMemMap, nomFreq)
 
diff --git a/neo/rawio/neuralynxrawio/neuralynxrawio.py b/neo/rawio/neuralynxrawio/neuralynxrawio.py
index 8f46bb9d0..1b5b91a2f 100644
--- a/neo/rawio/neuralynxrawio/neuralynxrawio.py
+++ b/neo/rawio/neuralynxrawio/neuralynxrawio.py
@@ -850,20 +850,21 @@ def get_nse_or_ntt_dtype(info, ext):
     """
     dtype = [('timestamp', 'uint64'), ('channel_id', 'uint32'), ('unit_id', 'uint32')]
 
-    # count feature
-    nb_feature = 0
-    for k in info.keys():
-        if k.startswith('Feature '):
-            nb_feature += 1
+    # for purpose of dtypes, features in the file are always fixed 8 presently,
+    # whether mentioned in the header or not. Features may not be listed in the header
+    # if no feature names are assigned in Neuralynx software.
+    nb_feature = 8
     dtype += [('features', 'int32', (nb_feature,))]
 
-    # count sample
+    # Number of samples are fixed in the file at 32 for .nse 32 * 4 for .ntt.
+    # WaveformLength may or may not be listed in the file depending on settings
+    # in the Neuralynx software, so don't try retrieving it.
     if ext == 'nse':
-        nb_sample = info['WaveformLength']
+        nb_sample = 32
         dtype += [('samples', 'int16', (nb_sample,))]
     elif ext == 'ntt':
-        nb_sample = info['WaveformLength']
-        nb_chan = 4  # check this if not tetrode
+        nb_sample = 32
+        nb_chan = 4
         dtype += [('samples', 'int16', (nb_sample, nb_chan))]
 
     return dtype
diff --git a/neo/rawio/neuralynxrawio/nlxheader.py b/neo/rawio/neuralynxrawio/nlxheader.py
index 0f3980390..9bb5fba79 100644
--- a/neo/rawio/neuralynxrawio/nlxheader.py
+++ b/neo/rawio/neuralynxrawio/nlxheader.py
@@ -97,6 +97,12 @@ def _to_bool(txt):
                             r'  At Time: (?P<time>\S+)',
             filename_regex=r'## File Name: (?P<filename>\S+)',
             datetimeformat='%m/%d/%Y %H:%M:%S.%f'),
+        # Cheetah version 5.6.0, some range of versions in between
+        'v5.6.0': dict(
+            datetime1_regex=r'## Time Opened: \(m/d/y\): (?P<date>\S+)'
+                            r' At Time: (?P<time>\S+)',
+            filename_regex=r'## File Name: (?P<filename>\S+)',
+            datetimeformat='%m/%d/%Y %H:%M:%S.%f'),
         # Cheetah version 5 before and including v 5.6.4 as well as version 1
         'bv5.6.4': dict(
             datetime1_regex=r'## Time Opened \(m/d/y\): (?P<date>\S+)'
@@ -223,6 +229,8 @@ def __init__(self, filename):
                 hpd = NlxHeader.header_pattern_dicts['bv5']
             elif av <= Version('5.4.0'):
                 hpd = NlxHeader.header_pattern_dicts['v5.4.0']
+            elif av == Version('5.6.0'):
+                hpd = NlxHeader.header_pattern_dicts['v5.6.0']
             elif av <= Version('5.6.4'):
                 hpd = NlxHeader.header_pattern_dicts['bv5.6.4']
             else:
@@ -303,11 +311,11 @@ def type_of_recording(self):
 
         elif 'FileType' in self:
 
-            if self['FileVersion'] in ['3.3', '3.4']:
+            if 'FileVersion' in self and self['FileVersion'] in ['3.3', '3.4']:
                 return self['AcquisitionSystem'].split()[1].upper()
 
             else:
-                return 'UNKNOWN'
+                return 'CHEETAH560' # only known case of FileType without FileVersion
 
         else:
             return 'UNKNOWN'
diff --git a/neo/rawio/openephysbinaryrawio.py b/neo/rawio/openephysbinaryrawio.py
index a59137696..7be1c6167 100644
--- a/neo/rawio/openephysbinaryrawio.py
+++ b/neo/rawio/openephysbinaryrawio.py
@@ -164,7 +164,7 @@ def _parse_header(self):
         event_channels = []
         for stream_ind, stream_name in enumerate(event_stream_names):
             info = self._evt_streams[0][0][stream_ind]
-            if 'states' in info:
+            if 'states' in info or 'channel_states' in info:
                 evt_channel_type = "epoch"
             else:
                 evt_channel_type = "event"
@@ -213,31 +213,35 @@ def _parse_header(self):
                         )
 
                     # # If available, use 'states' to compute event duration
-                    if 'states' in info and info["states"].size:
-                        states = info["states"]
-                        timestamps = info["timestamps"]
-                        labels = info["labels"]
-                        rising = np.where(states > 0)[0]
-                        falling = np.where(states < 0)[0]
-
-                        # infer durations
-                        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]
-
-                        info["rising"] = rising
-                        info["timestamps"] = timestamps[rising]
-                        info["labels"] = labels[rising]
-                        info["durations"] = durations
-                    else:
-                        info["durations"] = None
+                    info["durations"] = None
+                    # '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
+                            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]
+                            info["durations"] = durations
 
         # no spike read yet
         # can be implemented on user demand
@@ -395,9 +399,9 @@ def _event_count(self, block_index, seg_index, event_channel_index):
 
     def _get_event_timestamps(self, block_index, seg_index, event_channel_index, t_start, t_stop):
         info = self._evt_streams[block_index][seg_index][event_channel_index]
-        timestamps = info['timestamps']
+        timestamps = info["timestamps"]
         durations = info["durations"]
-        labels = info['labels']
+        labels = info["labels"]
 
         # slice it if needed
         if t_start is not None:
diff --git a/neo/rawio/plexon2rawio/plexon2rawio.py b/neo/rawio/plexon2rawio/plexon2rawio.py
index ef4359cab..4b2d08d88 100644
--- a/neo/rawio/plexon2rawio/plexon2rawio.py
+++ b/neo/rawio/plexon2rawio/plexon2rawio.py
@@ -223,7 +223,11 @@ def _parse_header(self):
                 # invalid datetime information if year is <1
                 if tmo.tm_year != 0:
                     microseconds = block_info['m_CreatorDateTimeMilliseconds'] * 1000
-                    dt = datetime(year=tmo.tm_year, month=tmo.tm_mon, day=tmo.tm_mday, hour=tmo.tm_hour,
+                    # tm_mon range is 0..11 https://cplusplus.com/reference/ctime/tm/
+                    # python is 1..12 https://docs.python.org/3/library/datetime.html#datetime.datetime
+                    # so month needs to be tm_mon+1; also tm_sec could cause problems in the case of leap
+                    # seconds, but this is harder to defend against.
+                    dt = datetime(year=tmo.tm_year, month=tmo.tm_mon+1, day=tmo.tm_mday, hour=tmo.tm_hour,
                                   minute=tmo.tm_min, second=tmo.tm_sec, microsecond=microseconds)
                     # ignoring daylight saving time information for now as timezone is unknown
 
diff --git a/neo/test/coretest/test_analogsignal.py b/neo/test/coretest/test_analogsignal.py
index 44c93b49a..f3e9c0b4b 100644
--- a/neo/test/coretest/test_analogsignal.py
+++ b/neo/test/coretest/test_analogsignal.py
@@ -286,7 +286,7 @@ def test__repr(self):
     def test__pretty(self):
         for i, signal in enumerate(self.signals):
             prepr = pretty(signal)
-            targ = (('AnalogSignal with %d channels of length %d; units %s; datatype %s \n'
+            targ = (('AnalogSignal with %d channels of length %d; units %s; datatype %s\n'
                      '' % (signal.shape[1], signal.shape[0],
                            signal.units.dimensionality.unicode, signal.dtype))
                     + ('annotations: %s\n' % signal.annotations)
diff --git a/neo/test/coretest/test_group.py b/neo/test/coretest/test_group.py
index ff760319f..cb05b78ee 100644
--- a/neo/test/coretest/test_group.py
+++ b/neo/test/coretest/test_group.py
@@ -16,6 +16,8 @@
 from neo.core.view import ChannelView
 from neo.core.group import Group
 from neo.core.block import Block
+from neo.core.imagesequence import ImageSequence
+from neo.core.regionofinterest import CircularRegionOfInterest
 
 
 class TestGroup(unittest.TestCase):
@@ -23,6 +25,7 @@ class TestGroup(unittest.TestCase):
     def setUp(self):
         test_data = np.random.rand(100, 8) * pq.mV
         channel_names = np.array(["a", "b", "c", "d", "e", "f", "g", "h"])
+        test_image_data = np.random.rand(640).reshape(10, 8, 8)
         self.test_signal = AnalogSignal(test_data,
                                         sampling_period=0.1 * pq.ms,
                                         name="test signal",
@@ -34,14 +37,19 @@ def setUp(self):
                               description="this is a view of a test signal",
                               array_annotations={"something": np.array(["A", "B", "C", "D"])},
                               sLaTfat="fish")
+        self.test_image_seq = ImageSequence(test_image_data,
+                                            frame_duration=20 * pq.ms,
+                                            spatial_scale=1 * pq.um)
+        self.roi = CircularRegionOfInterest(self.test_image_seq, 0, 0, 3)
         self.test_spiketrains = [SpikeTrain(np.arange(100.0), units="ms", t_stop=200),
                                  SpikeTrain(np.arange(0.5, 100.5), units="ms", t_stop=200)]
         self.test_segment = Segment()
         self.test_segment.analogsignals.append(self.test_signal)
         self.test_segment.spiketrains.extend(self.test_spiketrains)
+        self.test_segment.imagesequences.append(self.test_image_seq)
 
     def test_create_group(self):
-        objects = [self.test_view, self.test_signal]
+        objects = [self.test_view, self.test_signal, self.test_image_seq, self.roi]
         objects.extend(self.test_spiketrains)
         group = Group(objects)
 
@@ -49,6 +57,8 @@ def test_create_group(self):
         assert group.spiketrains[0] is self.test_spiketrains[0]
         assert group.spiketrains[1] is self.test_spiketrains[1]
         assert group.channelviews[0] is self.test_view
+        assert group.imagesequences[0] is self.test_image_seq
+        assert group.regionsofinterest[0] is self.roi
         assert len(group.irregularlysampledsignals) == 0
 
     def test_create_empty_group(self):
diff --git a/neo/test/coretest/test_imagesequence.py b/neo/test/coretest/test_imagesequence.py
index 4928fe515..a4fd8e768 100644
--- a/neo/test/coretest/test_imagesequence.py
+++ b/neo/test/coretest/test_imagesequence.py
@@ -39,7 +39,7 @@ def test_error_spatial_scale(self):
 
     def test_units(self):
         with self.assertRaises(TypeError):
-            ImageSequence(self.data, sampling_rate=500 * pq.Hz, spatial_scale=1 * pq.um)
+            ImageSequence(self.data, units=None, sampling_rate=500 * pq.Hz, spatial_scale=1 * pq.um)
 
     def test_wrong_dimensions(self):
         seq = ImageSequence(self.data, sampling_rate=500 * pq.Hz,
@@ -71,8 +71,7 @@ def test_t_start(self):
 
 
 class TestMethodImageSequence(unittest.TestCase):
-    def fake_region_of_interest(self):
-        self.rect_ROI = RectangularRegionOfInterest(2, 2, 2, 2)
+    def _create_test_objects(self):
         self.data = []
         for frame in range(25):
             self.data.append([])
@@ -80,27 +79,29 @@ def fake_region_of_interest(self):
                 self.data[frame].append([])
                 for x in range(5):
                     self.data[frame][y].append(x)
-
-    def test_signal_from_region(self):
-        self.fake_region_of_interest()
-        seq = ImageSequence(
+        self.seq = ImageSequence(
             self.data,
             units="V",
             sampling_rate=500 * pq.Hz,
             t_start=250 * pq.ms,
             spatial_scale=1 * pq.um,
         )
-        signals = seq.signal_from_region(self.rect_ROI)
+        self.rect_ROI = RectangularRegionOfInterest(self.seq, 2, 2, 2, 2)
+
+    def test_signal_from_region(self):
+        self._create_test_objects()
+        signals = self.seq.signal_from_region(self.rect_ROI)
         self.assertIsInstance(signals, list)
         self.assertEqual(len(signals), 1)
         for signal in signals:
             self.assertIsInstance(signal, AnalogSignal)
-            self.assertEqual(signal.t_start, seq.t_start)
-            self.assertEqual(signal.sampling_period, seq.frame_duration)
+            self.assertEqual(signal.t_start, self.seq.t_start)
+            self.assertEqual(signal.sampling_period, self.seq.frame_duration)
         with self.assertRaises(ValueError):  # no pixels in region
+            zero_size_roi = RectangularRegionOfInterest(self.seq, 1, 1, 0, 0)
             ImageSequence(
                 self.data, units="V", sampling_rate=500 * pq.Hz, spatial_scale=1 * pq.um
-            ).signal_from_region(RectangularRegionOfInterest(1, 1, 0, 0))
+            ).signal_from_region(zero_size_roi)
         with self.assertRaises(ValueError):
             ImageSequence(
                 self.data, units="V", sampling_rate=500 * pq.Hz, spatial_scale=1 * pq.um
diff --git a/neo/test/coretest/test_irregularysampledsignal.py b/neo/test/coretest/test_irregularysampledsignal.py
index fd05f5d07..5ec4742e1 100644
--- a/neo/test/coretest/test_irregularysampledsignal.py
+++ b/neo/test/coretest/test_irregularysampledsignal.py
@@ -806,7 +806,7 @@ def test__divide_signal_by_const_should_preserve_data_complement(self):
     def test__pretty(self):
         res = pretty(self.signal1)
         signal = self.signal1
-        targ = (("IrregularlySampledSignal with %d channels of length %d; units %s; datatype %s \n"
+        targ = (("IrregularlySampledSignal with %d channels of length %d; units %s; datatype %s\n"
                  "" % (signal.shape[1], signal.shape[0], signal.units.dimensionality.unicode,
                        signal.dtype))
                 + ("name: '{}'\ndescription: '{}'\n".format(signal.name, signal.description))
diff --git a/neo/test/coretest/test_regionofinterest.py b/neo/test/coretest/test_regionofinterest.py
index b6ea4eba3..8f538c6e1 100644
--- a/neo/test/coretest/test_regionofinterest.py
+++ b/neo/test/coretest/test_regionofinterest.py
@@ -1,31 +1,37 @@
-from neo.core.regionofinterest import RectangularRegionOfInterest, \
-    CircularRegionOfInterest,\
+import quantities as pq
+from neo.core.regionofinterest import (
+    RectangularRegionOfInterest,
+    CircularRegionOfInterest,
     PolygonRegionOfInterest
+)
+from neo.core.imagesequence import ImageSequence
 import unittest
 
 
 class Test_CircularRegionOfInterest(unittest.TestCase):
 
     def test_result(self):
-
-        self.assertEqual((CircularRegionOfInterest(6, 6, 1).pixels_in_region()),
+        seq = ImageSequence([[[]]], spatial_scale=1, frame_duration=20 * pq.ms)
+        self.assertEqual((CircularRegionOfInterest(seq, 6, 6, 1).pixels_in_region()),
                          [[6, 5], [5, 6], [6, 6]])
-        self.assertEqual((CircularRegionOfInterest(6, 6, 1.01).pixels_in_region()),
+        self.assertEqual((CircularRegionOfInterest(seq, 6, 6, 1.01).pixels_in_region()),
                          [[6, 5], [5, 6], [6, 6], [7, 6], [6, 7]])
 
 
 class Test_RectangularRegionOfInterest(unittest.TestCase):
 
     def test_result(self):
-        self.assertEqual(RectangularRegionOfInterest(5, 5, 2, 2).pixels_in_region(),
+        seq = ImageSequence([[[]]], spatial_scale=1, frame_duration=20 * pq.ms)
+        self.assertEqual(RectangularRegionOfInterest(seq, 5, 5, 2, 2).pixels_in_region(),
                          [[4, 4], [5, 4], [4, 5], [5, 5]])
 
 
 class Test_PolygonRegionOfInterest(unittest.TestCase):
 
     def test_result(self):
+        seq = ImageSequence([[[]]], spatial_scale=1, frame_duration=20 * pq.ms)
         self.assertEqual(
-            PolygonRegionOfInterest((3, 3), (2, 5), (5, 5), (5, 1), (1, 1)).pixels_in_region(),
+            PolygonRegionOfInterest(seq, (3, 3), (2, 5), (5, 5), (5, 1), (1, 1)).pixels_in_region(),
             [(1, 1), (2, 1), (3, 1), (4, 1), (2, 2), (3, 2),
              (4, 2), (3, 3), (4, 3), (3, 4), (4, 4)]
         )
diff --git a/neo/test/iotest/test_bci2000.py b/neo/test/iotest/test_bci2000io.py
similarity index 100%
rename from neo/test/iotest/test_bci2000.py
rename to neo/test/iotest/test_bci2000io.py
diff --git a/neo/test/iotest/test_medio.py b/neo/test/iotest/test_medio.py
index 9f75d7d54..f91485d8f 100644
--- a/neo/test/iotest/test_medio.py
+++ b/neo/test/iotest/test_medio.py
@@ -5,18 +5,21 @@
 import pathlib
 import unittest
 
+import quantities as pq
+import numpy as np
+
 from neo.io.medio import MedIO
 from neo.test.iotest.common_io_test import BaseTestIO
-from neo.test.iotest.tools import get_test_file_full_path
-from neo.io.proxyobjects import (AnalogSignalProxy,
-                SpikeTrainProxy, EventProxy, EpochProxy)
-from neo import (AnalogSignal, SpikeTrain)
 
-import quantities as pq
-import numpy as np
+try:
+    import dhn_med_py
+    HAVE_DHN_MED = True
+except ImportError:
+    HAVE_DHN_MED = False
 
 
-# This run standard tests, this is mandatory for all IOs
+# This runs standard tests, this is mandatory for all IOs
+@unittest.skipUnless(HAVE_DHN_MED, "requires dhn_med_py package and all its dependencies")
 class TestMedIO(BaseTestIO, unittest.TestCase, ):
     ioclass = MedIO
     entities_to_download = ['med']
@@ -31,22 +34,22 @@ def setUp(self):
         self.dirname = self.get_local_path('med/sine_waves.medd')
         self.dirname2 = self.get_local_path('med/test.medd')
         self.password = 'L2_password'
-                
+
     def test_read_segment_lazy(self):
-    
+
         r = MedIO(self.dirname, self.password)
         seg = r.read_segment(lazy=False)
-        
+
         # There will only be one analogsignal in this reading
         self.assertEqual(len(seg.analogsignals), 1)
         # Test that the correct number of samples are read, 5760000 samps for 3 channels
         self.assertEqual(seg.analogsignals[0].shape[0], 5760000)
         self.assertEqual(seg.analogsignals[0].shape[1], 3)
-        
+
         # Test the first sample value of all 3 channels, which are
         # known to be [-1, -4, -4]
         np.testing.assert_array_equal(seg.analogsignals[0][0][:3], [-1, -4, -4])
-        
+
         for anasig in seg.analogsignals:
             self.assertNotEqual(anasig.size, 0)
         for st in seg.spiketrains:
@@ -61,61 +64,61 @@ def test_read_segment_lazy(self):
             assert ev.name is not None
         for ep in seg.epochs:
             assert ep.name is not None
-          
+
         r.close()
 
     def test_read_block(self):
-  
+
         r = MedIO(self.dirname, self.password)
         bl = r.read_block(lazy=True)
         self.assertTrue(bl.annotations)
-        
+
         for count, seg in enumerate(bl.segments):
             assert seg.name == 'Seg #' + str(count) + ' Block #0'
-            
+
         for anasig in seg.analogsignals:
                 assert anasig.name is not None
-                
+
         # Verify that the block annotations from the MED session are
         # read properly.  There are a lot of annotations, so we'll just
         # spot-check a couple of them.
         assert(bl.annotations['metadata']['recording_country'] == 'United States')
         assert(bl.annotations['metadata']['AC_line_frequency'] == 60.0)
-        
+
         r.close()
-        
+
     def test_read_segment_with_time_slice(self):
         """
         Test loading of a time slice and check resulting times
         """
         r = MedIO(self.dirname, self.password)
         seg = r.read_segment(time_slice=None)
-        
+
         # spike and epoch timestamps are not being read
         self.assertEqual(len(seg.spiketrains), 0)
         self.assertEqual(len(seg.epochs), 1)
         self.assertEqual(len(seg.epochs[0]), 0)
-        
+
         # Test for 180 events (1 per second for 3 minute recording)
         self.assertEqual(len(seg.events), 1)
         self.assertEqual(len(seg.events[0]), 180)
-        
+
         for asig in seg.analogsignals:
             self.assertEqual(asig.shape[0], 5760000)
         n_channels = sum(a.shape[-1] for a in seg.analogsignals)
         self.assertEqual(n_channels, 3)
-            
+
         t_start, t_stop = 500 * pq.ms, 800 * pq.ms
         seg = r.read_segment(time_slice=(t_start, t_stop))
-        
+
         # Test that 300 ms were read, which at 32 kHz, is 9600 samples
         self.assertAlmostEqual(seg.analogsignals[0].shape[0], 9600, delta=1.)
         # Test that it read from 3 channels
         self.assertEqual(seg.analogsignals[0].shape[1], 3)
-            
+
         self.assertAlmostEqual(seg.t_start.rescale(t_start.units), t_start, delta=5.)
         self.assertAlmostEqual(seg.t_stop.rescale(t_stop.units), t_stop, delta=5.)
-            
+
         r.close()
 
 
diff --git a/neo/test/iotest/test_plexon2io.py b/neo/test/iotest/test_plexon2io.py
index 97c09b287..81d076d16 100644
--- a/neo/test/iotest/test_plexon2io.py
+++ b/neo/test/iotest/test_plexon2io.py
@@ -10,6 +10,14 @@
 from neo.test.rawiotest.test_plexon2rawio import TestPlexon2RawIO
 
 
+try:
+    from neo.rawio.plexon2rawio.pypl2 import pypl2lib
+    HAVE_PYPL2 = True
+except (ImportError, TimeoutError):
+    HAVE_PYPL2 = False
+
+
+@unittest.skipUnless(HAVE_PYPL2, "requires pypl package and all its dependencies")
 class TestPlexon2IO(BaseTestIO, unittest.TestCase):
     entities_to_download = TestPlexon2RawIO.entities_to_download
     entities_to_test = TestPlexon2RawIO.entities_to_test
diff --git a/neo/test/rawiotest/test_cedrawio.py b/neo/test/rawiotest/test_cedrawio.py
index 50a0e4beb..ea94ae2a0 100644
--- a/neo/test/rawiotest/test_cedrawio.py
+++ b/neo/test/rawiotest/test_cedrawio.py
@@ -4,6 +4,15 @@
 
 from neo.test.rawiotest.common_rawio_test import BaseTestRawIO
 
+try:
+    import sonpy
+    HAVE_SONPY = True
+except ImportError:
+    HAVE_SONPY = False
+
+
+# This runs standard tests, this is mandatory for all IOs
+@unittest.skipUnless(HAVE_SONPY, "requires sonpy package and all its dependencies")
 
 class TestCedRawIO(BaseTestRawIO, unittest.TestCase, ):
     rawioclass = CedRawIO
diff --git a/neo/test/rawiotest/test_medrawio.py b/neo/test/rawiotest/test_medrawio.py
index 7118cacfd..b2fd97c59 100644
--- a/neo/test/rawiotest/test_medrawio.py
+++ b/neo/test/rawiotest/test_medrawio.py
@@ -5,49 +5,58 @@
 
 from neo.test.rawiotest.common_rawio_test import BaseTestRawIO
 
+try:
+    import dhn_med_py
+    HAVE_DHN_MED = True
+except ImportError:
+    HAVE_DHN_MED = False
+
+
+# This runs standard tests, this is mandatory for all IOs
+@unittest.skipUnless(HAVE_DHN_MED, "requires dhn_med_py package and all its dependencies")
 class TestMedRawIO(BaseTestRawIO, unittest.TestCase, ):
     rawioclass = MedRawIO
     entities_to_download = [
         'med'
     ]
     entities_to_test = ['med/sine_waves.medd', 'med/test.medd']
-    
+
     def test_close(self):
-    
+
         filename = self.get_local_path('med/sine_waves.medd')
-        
+
         raw_io1 = MedRawIO(filename, password='L2_password')
         raw_io1.parse_header()
         raw_io1.close()
-        
+
         raw_io2 = MedRawIO(filename, password='L2_password')
         raw_io2.parse_header()
         raw_io2.close()
-        
-        
+
+
     def test_scan_med_directory(self):
-    
+
         filename = self.get_local_path('med/sine_waves.medd')
-        
+
         rawio = MedRawIO(filename, password='L2_password')
         rawio.parse_header()
-    
+
         # Test that correct metadata and boundaries are extracted
         # from the MED session.  We know the correct answers since
         # we generated the test files.
         self.assertEqual(rawio.signal_streams_count(), 1)
         self.assertEqual(rawio._segment_t_start(0, 0), 0)
         self.assertEqual(rawio._segment_t_stop(0, 0), 180)
-        
+
         # Verify it found all 3 channels
         self.assertEqual(rawio.num_channels_in_session, 3)
         self.assertEqual(rawio.header['signal_channels'].size, 3)
-        
+
         # Verify if found the names of the 3 channels
         self.assertEqual(rawio.header['signal_channels'][0][0], 'CSC_0001')
         self.assertEqual(rawio.header['signal_channels'][1][0], 'CSC_0002')
         self.assertEqual(rawio.header['signal_channels'][2][0], 'CSC_0003')
-        
+
         # Read first 3 seconds of data from all channels
         raw_chunk = rawio.get_analogsignal_chunk(block_index=0,
                                 seg_index=0,
@@ -55,11 +64,11 @@ def test_scan_med_directory(self):
                                 i_stop=96000,
                                 stream_index=0,
                                 channel_indexes=None)
-                                
+
         # Test the first sample value of all 3 channels, which are
         # known to be [-1, -4, -4]
         np.testing.assert_array_equal(raw_chunk[0][:3], [-1, -4, -4])
-        
+
         # Read 1 second of data from the second channel
         raw_chunk = rawio.get_analogsignal_chunk(block_index=0,
                                 seg_index=0,
@@ -67,28 +76,28 @@ def test_scan_med_directory(self):
                                 i_stop=32000,
                                 stream_index=0,
                                 channel_indexes=[1])
-               
+
         # Test known first sample of second channel: [-4]
         self.assertEqual(raw_chunk[0][0], -4)
-        
+
         rawio.close()
-        
+
         # Test on second test dataset, test.medd.
         filename = self.get_local_path('med/test.medd')
-        
+
         rawio = MedRawIO(filename, password='L2_password')
         rawio.parse_header()
-        
+
         # Test that correct metadata and boundaries are extracted
         # from the MED session.  We know the correct answers since
         # we generated the test files.
-        
+
         # For this dataset, there are 3 continuous data ranges, with
         # approximately 10 seconds between the ranges.
         # There are 3 channels, two with a frequency of 1000 Hz and one
         # with a frequency of 5000 Hz.
         self.assertEqual(rawio.signal_streams_count(), 2)
-        
+
         # Segment 0
         self.assertEqual(rawio._segment_t_start(0, 0), 0)
         self.assertEqual(rawio._segment_t_stop(0, 0), 39.8898)
@@ -98,16 +107,16 @@ def test_scan_med_directory(self):
         # Segment 2
         self.assertEqual(rawio._segment_t_start(0, 2), 97.242057)
         self.assertEqual(rawio._segment_t_stop(0, 2), 180.016702)
-        
+
         # Verify it found all 3 channels.
         self.assertEqual(rawio.num_channels_in_session, 3)
         self.assertEqual(rawio.header['signal_channels'].size, 3)
-  
+
         # Verity if found the names of the 3 channels
         self.assertEqual(rawio.header['signal_channels'][0][0], '5k_ch1')
         self.assertEqual(rawio.header['signal_channels'][1][0], '1k_ch1')
         self.assertEqual(rawio.header['signal_channels'][2][0], '1k_ch2')
-        
+
         # Read first 3 seconds of data from the first channel (5k_ch1)
         raw_chunk = rawio.get_analogsignal_chunk(block_index=0,
                                 seg_index=0,
@@ -115,14 +124,14 @@ def test_scan_med_directory(self):
                                 i_stop=15000,
                                 stream_index=0,
                                 channel_indexes=None)
-                                
+
         # Test the first three sample values returned, which are
         # known to be [-80, -79, -78]
         self.assertEqual(raw_chunk[0][0], -80)
         self.assertEqual(raw_chunk[1][0], -79)
         self.assertEqual(raw_chunk[2][0], -78)
-   
-        
+
+
         # Read first 3 seconds of data from the second channel and third
         # channels (1k_ch1 and 1k_ch2)
         raw_chunk = rawio.get_analogsignal_chunk(block_index=0,
@@ -131,11 +140,11 @@ def test_scan_med_directory(self):
                                 i_stop=3000,
                                 stream_index=1,
                                 channel_indexes=None)
-               
+
         # Test first sample returned of both channels, which are known
         # to be [-79, -80]
         np.testing.assert_array_equal(raw_chunk[0][:2], [-79, -80])
-        
+
         # Read first 3 seconds of data from the second segment of the first channel (5k_ch1)
         raw_chunk = rawio.get_analogsignal_chunk(block_index=0,
                                 seg_index=1,
@@ -143,15 +152,15 @@ def test_scan_med_directory(self):
                                 i_stop=15000,
                                 stream_index=0,
                                 channel_indexes=None)
-                                
+
         # Test the first three sample values returned, which are
         # known to be [22, 23, 24]
         self.assertEqual(raw_chunk[0][0], 22)
         self.assertEqual(raw_chunk[1][0], 23)
         self.assertEqual(raw_chunk[2][0], 24)
-                                
+
         self.assertEqual(len(rawio.header['event_channels']), 2)
-        
+
         # Verify that there are 5 events in the dataset.
         # They are 3 "Note" type events, and 2 "NlxP", or neuralynx, type events.
         # The first segment has one event, and the second and third segments
@@ -159,39 +168,39 @@ def test_scan_med_directory(self):
         self.assertEqual(rawio.event_count(0, 0, 0), 1)
         self.assertEqual(rawio.event_count(0, 1, 0), 2)
         self.assertEqual(rawio.event_count(0, 2, 0), 2)
-        
+
         # Get array of all events in first segment of data
         events = rawio._get_event_timestamps(0, 0, 0, rawio._segment_t_start(0, 0), rawio._segment_t_stop(0, 0))
         # Make sure it read 1 event
         self.assertEqual(len(events[0]), 1)
-        
+
         # Get array of all events in second segment of data
         events = rawio._get_event_timestamps(0, 1, 0, rawio._segment_t_start(0, 1), rawio._segment_t_stop(0, 1))
         # Make sure it read 2 events
         self.assertEqual(len(events[0]), 2)
-        
+
         # Verify the first event of the second segment is a Neuralynx type event, with correct time
         self.assertEqual(events[2][0][:4], 'NlxP')
         self.assertEqual(events[0][0], 51.703509)
-        
+
         # Get array of all events in third segment of data
         events = rawio._get_event_timestamps(0, 2, 0, rawio._segment_t_start(0, 2), rawio._segment_t_stop(0, 2))
         # Make sure it read 2 events
         self.assertEqual(len(events[0]), 2)
-        
+
         # Verify the second event of the second segment is a Neuralynx type event, with correct time
         self.assertEqual(events[2][1][:4], 'NlxP')
         self.assertEqual(events[0][1], 161.607036)
-        
+
         rawio.close()
-        
+
         # Test on second test dataset, test.medd, with preserving original timestamps.
         # Timestamps here are in UTC (seconds since midnight, 1 Jan 1970)
         filename = self.get_local_path('med/test.medd')
-        
+
         rawio = MedRawIO(filename, password='L2_password', keep_original_times=True)
         rawio.parse_header()
-        
+
         # Segment 0
         self.assertEqual(rawio._segment_t_start(0, 0), 1678111774.012236)
         self.assertEqual(rawio._segment_t_stop(0, 0), 1678111813.902036)
@@ -201,7 +210,7 @@ def test_scan_med_directory(self):
         # Segment 2
         self.assertEqual(rawio._segment_t_start(0, 2), 1678111871.254293)
         self.assertEqual(rawio._segment_t_stop(0, 2), 1678111954.028938)
-        
+
         # Verify that there are 5 events in the dataset.
         # They are 3 "Note" type events, and 2 "NlxP", or neuralynx, type events.
         # The first segment has one event, and the second and third segments
@@ -209,33 +218,32 @@ def test_scan_med_directory(self):
         self.assertEqual(rawio.event_count(0, 0, 0), 1)
         self.assertEqual(rawio.event_count(0, 1, 0), 2)
         self.assertEqual(rawio.event_count(0, 2, 0), 2)
-        
+
         # Get array of all events in first segment of data
         events = rawio._get_event_timestamps(0, 0, 0, rawio._segment_t_start(0, 0), rawio._segment_t_stop(0, 0))
         # Make sure it read 1 event
         self.assertEqual(len(events[0]), 1)
-        
+
         # Get array of all events in second segment of data
         events = rawio._get_event_timestamps(0, 1, 0, rawio._segment_t_start(0, 1), rawio._segment_t_stop(0, 1))
         # Make sure it read 2 events
         self.assertEqual(len(events[0]), 2)
-        
+
         # Verify the first event of the second segment is a Neuralynx type event, with correct time
         self.assertEqual(events[2][0][:4], 'NlxP')
         self.assertEqual(events[0][0], 1678111825.715745)
-        
+
         # Get array of all events in third segment of data
         events = rawio._get_event_timestamps(0, 2, 0, rawio._segment_t_start(0, 2), rawio._segment_t_stop(0, 2))
         # Make sure it read 2 events
         self.assertEqual(len(events[0]), 2)
-        
+
         # Verify the second event of the second segment is a Neuralynx type event, with correct time
         self.assertEqual(events[2][1][:4], 'NlxP')
         self.assertEqual(events[0][1], 1678111935.619272)
-        
+
         rawio.close()
-    
-    
+
+
 if __name__ == "__main__":
     unittest.main()
-
diff --git a/neo/test/rawiotest/test_plexon2rawio.py b/neo/test/rawiotest/test_plexon2rawio.py
index 618fa0970..627024fe3 100644
--- a/neo/test/rawiotest/test_plexon2rawio.py
+++ b/neo/test/rawiotest/test_plexon2rawio.py
@@ -13,7 +13,7 @@
 try:
     from neo.rawio.plexon2rawio.pypl2 import pypl2lib
     HAVE_PYPL2 = True
-except ImportError:
+except (ImportError, TimeoutError):
     HAVE_PYPL2 = False