[utils] do not copy nix_name annotation to different object types

Author: sprenger

neo/test/utils/test_misc.py

@@ -281,11 +281,11 @@ def test__get_epochs(self):
 
     def test__add_epoch(self):
         starts = Event(times=[0.5, 10.0, 25.2] * pq.s)
-        starts.annotate(event_type='trial start')
+        starts.annotate(event_type='trial start', nix_name='neo.event.0')
         starts.array_annotate(trial_id=[1, 2, 3])
 
         stops = Event(times=[5.5, 14.9, 30.1] * pq.s)
-        stops.annotate(event_type='trial stop')
+        stops.annotate(event_type='trial stop', nix_name='neo.event.1')
         stops.array_annotate(trial_id=[1, 2, 3])
 
         seg = Segment()
@@ -295,7 +295,7 @@ def test__add_epoch(self):
         ep_starts = add_epoch(seg, starts, pre=-300 * pq.ms, post=250 * pq.ms)
 
         assert_neo_object_is_compliant(ep_starts)
-        assert_same_annotations(ep_starts, starts)
+        self.assertDictEqual(ep_starts.annotations, {'event_type': 'trial start'})
         assert_arrays_almost_equal(ep_starts.times, starts.times - 300 * pq.ms, 1e-12)
         assert_arrays_almost_equal(ep_starts.durations,
                                    (550 * pq.ms).rescale(ep_starts.durations.units)
@@ -305,7 +305,7 @@ def test__add_epoch(self):
         ep_trials = add_epoch(seg, starts, stops)
 
         assert_neo_object_is_compliant(ep_trials)
-        assert_same_annotations(ep_trials, starts)
+        self.assertDictEqual(ep_trials.annotations, {'event_type': 'trial start'})
         assert_arrays_almost_equal(ep_trials.times, starts.times, 1e-12)
         assert_arrays_almost_equal(ep_trials.durations, stops - starts, 1e-12)
 
@@ -337,16 +337,16 @@ def test__match_events(self):
     def test__cut_block_by_epochs(self):
         epoch = Epoch([0.5, 10.0, 25.2] * pq.s, durations=[5.1, 4.8, 5.0] * pq.s,
                       t_start=.1 * pq.s)
-        epoch.annotate(epoch_type='a', pick='me')
+        epoch.annotate(epoch_type='a', pick='me', nix_name='neo.epoch.0')
         epoch.array_annotate(trial_id=[1, 2, 3])
 
         epoch2 = Epoch([0.6, 9.5, 16.8, 34.1] * pq.s, durations=[4.5, 4.8, 5.0, 5.0] * pq.s,
                        t_start=.1 * pq.s)
-        epoch2.annotate(epoch_type='b')
+        epoch2.annotate(epoch_type='b', nix_name='neo.epoch.1')
         epoch2.array_annotate(trial_id=[1, 2, 3, 4])
 
         event = Event(times=[0.5, 10.0, 25.2] * pq.s, t_start=.1 * pq.s)
-        event.annotate(event_type='trial start')
+        event.annotate(event_type='trial start', nix_name='neo.event.0')
         event.array_annotate(trial_id=[1, 2, 3])
 
         anasig = AnalogSignal(np.arange(50.0) * pq.mV, t_start=.1 * pq.s,
@@ -362,8 +362,8 @@ def test__cut_block_by_epochs(self):
                         array_annotations={'spikenum': np.arange(1, 9)})
 
         # test without resetting the time
-        seg = Segment()
-        seg2 = Segment(name='NoCut')
+        seg = Segment(nix_name='neo.segment.0')
+        seg2 = Segment(name='NoCut', nix_name='neo.segment.1')
         seg.epochs = [epoch, epoch2]
         seg.events = [event]
         seg.analogsignals = [anasig]
@@ -385,6 +385,10 @@ def test__cut_block_by_epochs(self):
             self.assertEqual(len(block.segments[epoch_idx].analogsignals), 1)
             self.assertEqual(len(block.segments[epoch_idx].irregularlysampledsignals), 1)
 
+            annos = block.segments[epoch_idx].annotations
+            self.assertIn('nix_name', annos)
+            self.assertTrue(annos['nix_name'].startswith('neo.segment.'))
+
             if epoch_idx != 0:
                 self.assertEqual(len(block.segments[epoch_idx].epochs), 1)
             else:
@@ -414,8 +418,8 @@ def test__cut_block_by_epochs(self):
                                                 t_stop=epoch.times[0] + epoch.durations[0]))
 
         # test with resetting the time
-        seg = Segment()
-        seg2 = Segment(name='NoCut')
+        seg = Segment(nix_name='neo.segment.0')
+        seg2 = Segment(name='NoCut', nix_name='neo.segment.1')
         seg.epochs = [epoch, epoch2]
         seg.events = [event]
         seg.analogsignals = [anasig]
@@ -436,6 +440,11 @@ def test__cut_block_by_epochs(self):
             self.assertEqual(len(block.segments[epoch_idx].spiketrains), 1)
             self.assertEqual(len(block.segments[epoch_idx].analogsignals), 1)
             self.assertEqual(len(block.segments[epoch_idx].irregularlysampledsignals), 1)
+
+            annos = block.segments[epoch_idx].annotations
+            self.assertIn('nix_name', annos)
+            self.assertTrue(annos['nix_name'].startswith('neo.segment.'))
+
             if epoch_idx != 0:
                 self.assertEqual(len(block.segments[epoch_idx].epochs), 1)
             else:
@@ -527,14 +536,18 @@ def test__add_epoch(self):
 
         regular_event = Event(times=loaded_event.times - 1 * loaded_event.units)
 
+        loaded_event.annotate(nix_name='neo.event.0')
+        regular_event.annotate(nix_name='neo.event.1')
+
         seg = Segment()
         seg.events = [regular_event, proxy_event]
 
         # test cutting with two events one of which is a proxy
         epoch = add_epoch(seg, regular_event, proxy_event)
 
         assert_neo_object_is_compliant(epoch)
-        assert_same_annotations(epoch, regular_event)
+        exp_annos = {k: v for k, v in regular_event.annotations.items() if k != 'nix_name'}
+        self.assertDictEqual(epoch.annotations, exp_annos)
         assert_arrays_almost_equal(epoch.times, regular_event.times, 1e-12)
         assert_arrays_almost_equal(epoch.durations,
                                    np.ones(regular_event.shape) * loaded_event.units, 1e-12)