def check_creation(self, unit): assert_neo_object_is_compliant(unit) seed = unit.annotations['seed'] targ0 = get_fake_value('channel_indexes', np.ndarray, dim=1, dtype='i', seed=seed+0) assert_arrays_equal(unit.channel_indexes, targ0) targ1 = get_fake_value('name', str, seed=seed+1, obj=Unit) self.assertEqual(unit.name, targ1) targ2 = get_fake_value('description', str, seed=seed+2, obj=Unit) self.assertEqual(unit.description, targ2) targ3 = get_fake_value('file_origin', str) self.assertEqual(unit.file_origin, targ3) targ4 = get_annotations() targ4['seed'] = seed self.assertEqual(unit.annotations, targ4) self.assertTrue(hasattr(unit, 'spikes')) self.assertTrue(hasattr(unit, 'spiketrains')) self.assertEqual(len(unit.spikes), self.nchildren) self.assertEqual(len(unit.spiketrains), self.nchildren)
def test_unit_merge(self): self.unit1.merge(self.unit2) spikeres1 = [sig.name for sig in self.unit1.spikes] spikeres2 = [sig.name for sig in self.unit2.spikes] trainres1 = [sig.name for sig in self.unit1.spiketrains] trainres2 = [sig.name for sig in self.unit2.spiketrains] self.assertEqual(spikeres1, self.spikenames) self.assertEqual(spikeres2, self.spikenames2) self.assertEqual(trainres1, self.trainnames) self.assertEqual(trainres2, self.trainnames2) for res, targ in zip(self.unit1.spikes, self.spike): self.assertEqual(res, targ) for res, targ in zip(self.unit2.spikes, self.spike2): self.assertEqual(res, targ) for res, targ in zip(self.unit1.spiketrains, self.train): assert_arrays_equal(res, targ) for res, targ in zip(self.unit2.spiketrains, self.train2): assert_arrays_equal(res, targ)
def test_read_spiketrain_using_eager(self): io = self.io_cls(self.test_file) st3 = io.read_spiketrain(lazy=False, channel_index=3) self.assertIsInstance(st3, SpikeTrain) assert_arrays_equal( st3, SpikeTrain(numpy.arange(3, 104, dtype=float), t_start=0 * pq.s, t_stop=104 * pq.s, units=pq.ms) )
def test_time_slice_empty(self): params = {'test2': 'y1', 'test3': True} epc = Epoch([] * pq.ms, durations=[] * pq.ns, labels=np.array([], dtype='S'), name='test', description='tester', file_origin='test.file', test1=1, **params) epc.annotate(test1=1.1, test0=[1, 2]) assert_neo_object_is_compliant(epc) targ = Epoch([] * pq.ms, durations=[] * pq.ns, labels=np.array([], dtype='S'), name='test', description='tester', file_origin='test.file', test1=1, **params) targ.annotate(test1=1.1, test0=[1, 2]) assert_neo_object_is_compliant(targ) t_start = 1.2 t_stop = 1.6 result = epc.time_slice(t_start, t_stop) assert_arrays_equal(result.times, targ.times) assert_arrays_equal(result.durations, targ.durations) assert_arrays_equal(result.labels, targ.labels) self.assertEqual(result.name, targ.name) self.assertEqual(result.description, targ.description) self.assertEqual(result.file_origin, targ.file_origin) self.assertEqual(result.annotations['test0'], targ.annotations['test0']) self.assertEqual(result.annotations['test1'], targ.annotations['test1']) self.assertEqual(result.annotations['test2'], targ.annotations['test2']) assert_arrays_equal(result.array_annotations['durations'], np.array([], dtype='float64') * pq.ns) assert_arrays_equal(result.array_annotations['labels'], np.array([], dtype='S')) self.assertIsInstance(result.array_annotations, ArrayDict)
def test_recordingchannelgroup__merge(self): self.rcg1.merge(self.rcg2) chanres1 = [chan.name for chan in self.rcg1.recordingchannels] chanres2 = [chan.name for chan in self.rcg2.recordingchannels] unitres1 = [unit.name for unit in self.rcg1.units] unitres2 = [unit.name for unit in self.rcg2.units] sigarrres1 = [sigarr.name for sigarr in self.rcg1.analogsignalarrays] sigarrres2 = [sigarr.name for sigarr in self.rcg2.analogsignalarrays] self.assertEqual(chanres1, self.rchannames) self.assertEqual(chanres2, self.rchannames2) self.assertEqual(unitres1, self.unitnames) self.assertEqual(unitres2, self.unitnames2) self.assertEqual(sigarrres1, self.sigarrnames) self.assertEqual(sigarrres2, self.sigarrnames2) for res, targ in zip(self.rcg1.analogsignalarrays, self.sigarr): assert_arrays_equal(res, targ) for res, targ in zip(self.rcg2.analogsignalarrays, self.sigarr2): assert_arrays_equal(res, targ)
def test_time_slice_differnt_units(self): params = {'test2': 'y1', 'test3': True} arr_ann = {'index': np.arange(3), 'test': ['a', 'b', 'c']} epc = Epoch([1.1, 1.5, 1.7] * pq.ms, durations=[20, 40, 60] * pq.ns, labels=np.array(['test epoch 1', 'test epoch 2', 'test epoch 3'], dtype='S'), name='test', description='tester', file_origin='test.file', test1=1, array_annotations=arr_ann, **params) epc.annotate(test1=1.1, test0=[1, 2]) assert_neo_object_is_compliant(epc) targ = Epoch([1.5] * pq.ms, durations=[40] * pq.ns, labels=np.array(['test epoch 2'], dtype='S'), name='test', description='tester', file_origin='test.file', test1=1, array_annotations={'index': [1], 'test': ['b']}, **params) targ.annotate(test1=1.1, test0=[1, 2]) assert_neo_object_is_compliant(targ) t_start = 0.0012 * pq.s t_stop = 0.0016 * pq.s result = epc.time_slice(t_start, t_stop) assert_arrays_equal(result.times, targ.times) assert_arrays_equal(result.durations, targ.durations) assert_arrays_equal(result.labels, targ.labels) self.assertEqual(result.name, targ.name) self.assertEqual(result.description, targ.description) self.assertEqual(result.file_origin, targ.file_origin) self.assertEqual(result.annotations['test0'], targ.annotations['test0']) self.assertEqual(result.annotations['test1'], targ.annotations['test1']) self.assertEqual(result.annotations['test2'], targ.annotations['test2']) assert_arrays_equal(result.array_annotations['index'], np.array([1])) assert_arrays_equal(result.array_annotations['test'], np.array(['b'])) self.assertIsInstance(result.array_annotations, ArrayDict)
def test__pickle(self): arr_ann = {'index': np.arange(3), 'test': ['a', 'b', 'c']} epoch1 = Epoch(np.arange(0, 30, 10) * pq.s, durations=[1, 2, 3] * pq.s, labels=np.array(['t0', 't1', 't2'], dtype='S'), units='s', annotation1="foo", annotation2="bar", array_annotations=arr_ann) fobj = open('./pickle', 'wb') pickle.dump(epoch1, fobj) fobj.close() fobj = open('./pickle', 'rb') try: epoch2 = pickle.load(fobj) except ValueError: epoch2 = None fobj.close() assert_array_equal(epoch1.times, epoch2.times) self.assertEqual(epoch2.annotations, epoch1.annotations) assert_arrays_equal(epoch2.array_annotations['index'], np.array(arr_ann['index'])) assert_arrays_equal(epoch2.array_annotations['test'], np.array(arr_ann['test'])) self.assertIsInstance(epoch2.array_annotations, ArrayDict) # Make sure the dict can perform correct checks after unpickling epoch2.array_annotations['anno3'] = list(range(3, 6)) with self.assertRaises(ValueError): epoch2.array_annotations['anno4'] = [2, 1] os.remove('./pickle')
def test_recordingchannelgroup__compliance(self): assert_neo_object_is_compliant(self.rcg1) assert_neo_object_is_compliant(self.rcg2) self.assertEqual(self.rcg1.name, 'test') self.assertEqual(self.rcg2.name, 'test') self.assertEqual(self.rcg1.description, 'tester 1') self.assertEqual(self.rcg2.description, 'tester 2') self.assertEqual(self.rcg1.file_origin, 'test.file') self.assertEqual(self.rcg2.file_origin, 'test.file') self.assertEqual(self.rcg1.annotations['testarg0'], [1, 2, 3]) self.assertEqual(self.rcg2.annotations['testarg10'], [1, 2, 3]) self.assertEqual(self.rcg1.annotations['testarg1'], 1.1) self.assertEqual(self.rcg2.annotations['testarg1'], 1) self.assertEqual(self.rcg2.annotations['testarg11'], 1.1) self.assertEqual(self.rcg1.annotations['testarg2'], 'yes') self.assertEqual(self.rcg2.annotations['testarg2'], 'yes') self.assertTrue(self.rcg1.annotations['testarg3']) self.assertTrue(self.rcg2.annotations['testarg3']) self.assertTrue(hasattr(self.rcg1, 'units')) self.assertTrue(hasattr(self.rcg2, 'units')) self.assertEqual(len(self.rcg1.units), 2) self.assertEqual(len(self.rcg2.units), 3) self.assertEqual(self.rcg1.units, self.units1) self.assertEqual(self.rcg2.units, self.units2) self.assertTrue(hasattr(self.rcg1, 'recordingchannels')) self.assertTrue(hasattr(self.rcg2, 'recordingchannels')) self.assertEqual(len(self.rcg1.recordingchannels), 2) self.assertEqual(len(self.rcg2.recordingchannels), 3) for res, targ in zip(self.rcg1.recordingchannels, self.rchan1): self.assertEqual(res.name, targ.name) for res, targ in zip(self.rcg2.recordingchannels, self.rchan2): self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.rcg1, 'analogsignalarrays')) self.assertTrue(hasattr(self.rcg2, 'analogsignalarrays')) self.assertEqual(len(self.rcg1.analogsignalarrays), 2) self.assertEqual(len(self.rcg2.analogsignalarrays), 3) for res, targ in zip(self.rcg1.analogsignalarrays, self.sigarr1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.rcg2.analogsignalarrays, self.sigarr2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name)
def test__time_slice__different_units(self): self.signal2.t_start = 10.0 * pq.ms assert_neo_object_is_compliant(self.signal2) t_start = 2 * pq.s + 10.0 * pq.ms t_stop = 4 * pq.s + 10.0 * pq.ms result = self.signal2.time_slice(t_start, t_stop) self.assertIsInstance(result, AnalogSignalArray) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) targ = AnalogSignalArray(np.array([[2, 3], [2, 3]]).T, t_start=t_start.rescale(pq.ms), sampling_rate=1.0*pq.Hz, units='mV', name='spam', description='eggs', file_origin='testfile.txt', arg1='test') assert_neo_object_is_compliant(result) assert_neo_object_is_compliant(self.signal2) self.assertEqual(self.signal2.t_start, 10.0 * pq.ms) self.assertAlmostEqual(result.t_stop, t_stop, delta=1e-12*pq.ms) self.assertAlmostEqual(result.t_start, t_start, delta=1e-12*pq.ms) assert_arrays_almost_equal(result.times, targ.times, 1e-12*pq.ms) self.assertEqual(result.sampling_rate, targ.sampling_rate) assert_arrays_equal(result, targ) assert_same_sub_schema(result, targ)
def test__time_slice__offset(self): self.signal2.t_start = 10.0 * pq.s assert_neo_object_is_compliant(self.signal2) t_start = 12 * pq.s t_stop = 14 * pq.s result = self.signal2.time_slice(t_start, t_stop) self.assertIsInstance(result, AnalogSignalArray) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) targ = AnalogSignalArray(np.array([[2, 3], [2, 3]]).T, t_start=12.0*pq.ms, sampling_rate=1.0*pq.Hz, units='mV', name='spam', description='eggs', file_origin='testfile.txt', arg1='test') assert_neo_object_is_compliant(result) self.assertEqual(self.signal2.t_start, 10.0 * pq.s) self.assertEqual(result.t_stop, t_stop) self.assertEqual(result.t_start, t_start) self.assertEqual(result.sampling_rate, targ.sampling_rate) assert_arrays_equal(result, targ) assert_same_sub_schema(result, targ)
def test__add_two_consistent_signals_should_preserve_data_complement(self): data2 = np.arange(10.0, 20.0) data2quant = data2 * pq.mV signal2 = IrregularlySampledSignal(self.time1quant, signal=data2quant) assert_neo_object_is_compliant(signal2) result = self.signal1 + signal2 self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) targ = IrregularlySampledSignal(self.time1quant, signal=np.arange(10.0, 30.0, 2.0), units="mV", name='spam', description='eggs', file_origin='testfile.txt', arg1='test') assert_neo_object_is_compliant(targ) assert_array_equal(result, targ) assert_array_equal(self.time1quant, targ.times) assert_array_equal(result.times, targ.times) assert_same_sub_schema(result, targ)
def test_time_slice_differnt_units(self): targdataquant = [[1.0], [2.0], [3.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime[1:4] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = 250 t_start = 0.015 * pq.s t_stop = .250 * pq.s result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict)
def test__create_from_array(self): times = numpy.arange(10) t_start = 0.0*pq.s t_stop = 10000.0*pq.ms st = SpikeTrain(times, t_start=t_start, t_stop=t_stop, units="s") self.assertEqual(st.t_stop, t_stop) assert_arrays_equal(st, times*pq.s)
def test_comparison_operators(self): assert_arrays_equal(self.signal1 >= 5*pq.nA, np.array([False, False, False, False, False, True, True, True, True, True])) assert_arrays_equal(self.signal1 >= 5*pq.pA, np.array([False, True, True, True, True, True, True, True, True, True]))
def test__add_two_consistent_signals_should_preserve_data_complement(self): data2 = np.arange(10.0, 20.0) data2quant = data2 * pq.mV signal2 = AnalogSignal(data2quant, sampling_rate=1 * pq.kHz) assert_neo_object_is_compliant(signal2) result = self.signal1 + signal2 self.assertIsInstance(result, AnalogSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, "spam") self.assertEqual(result.description, "eggs") self.assertEqual(result.file_origin, "testfile.txt") self.assertEqual(result.annotations, {"arg1": "test"}) targ = AnalogSignal( np.arange(10.0, 30.0, 2.0), units="mV", sampling_rate=1 * pq.kHz, name="spam", description="eggs", file_origin="testfile.txt", arg1="test", ) assert_neo_object_is_compliant(targ) assert_arrays_equal(result, targ) assert_same_sub_schema(result, targ)
def test_time_slice_differnt_units(self): params = {'test2': 'y1', 'test3': True} evt = Event([0.1, 0.5, 1.1, 1.5, 1.7, 2.2, 2.9, 3.1, 3.3]*pq.ms, name='test', description='tester', file_origin='test.file', test1=1, **params) assert_neo_object_is_compliant(evt) evt.annotate(test1=1.1, test0=[1, 2]) targ = Event([ 2.2, 2.9 ]*pq.ms, name='test', description='tester', file_origin='test.file', test1=1, **params) assert_neo_object_is_compliant(targ) targ.annotate(test1=1.1, test0=[1, 2]) t_start = 0.002 * pq.s t_stop = 0.003 * pq.s result = evt.time_slice(t_start, t_stop) assert_arrays_equal(targ, result) self.assertEqual(targ.name, result.name) self.assertEqual(targ.description, result.description) self.assertEqual(targ.file_origin, result.file_origin) self.assertEqual(targ.annotations['test0'], result.annotations['test0']) self.assertEqual(targ.annotations['test1'], result.annotations['test1']) self.assertEqual(targ.annotations['test2'], result.annotations['test2'])
def check_creation(self, rchan): assert_neo_object_is_compliant(rchan) seed = rchan.annotations['seed'] targ0 = get_fake_value('index', int, seed=seed+0, obj=RecordingChannel) self.assertEqual(rchan.index, targ0) targ1 = get_fake_value('coordinate', pq.Quantity, dim=1, seed=seed+1) assert_arrays_equal(rchan.coordinate, targ1) targ2 = get_fake_value('name', str, seed=seed+2, obj=RecordingChannel) self.assertEqual(rchan.name, targ2) targ3 = get_fake_value('description', str, seed=seed+3, obj=RecordingChannel) self.assertEqual(rchan.description, targ3) targ4 = get_fake_value('file_origin', str) self.assertEqual(rchan.file_origin, targ4) targ5 = get_annotations() targ5['seed'] = seed self.assertEqual(rchan.annotations, targ5) self.assertTrue(hasattr(rchan, 'analogsignals')) self.assertTrue(hasattr(rchan, 'irregularlysampledsignals')) self.assertEqual(len(rchan.analogsignals), self.nchildren) self.assertEqual(len(rchan.irregularlysampledsignals), self.nchildren)
def testInitDefaults(self): rcg = RecordingChannelGroup() self.assertEqual(rcg.name, None) self.assertEqual(rcg.file_origin, None) self.assertEqual(rcg.recordingchannels, []) self.assertEqual(rcg.analogsignalarrays, []) assert_arrays_equal(rcg.channel_names, np.array([])) assert_arrays_equal(rcg.channel_indexes, np.array([]))
def test__channelindex__init_defaults(self): chx = ChannelIndex(index=np.array([1])) assert_neo_object_is_compliant(chx) self.assertEqual(chx.name, None) self.assertEqual(chx.file_origin, None) self.assertEqual(chx.analogsignals, []) assert_arrays_equal(chx.channel_names, np.array([], dtype='S')) assert_arrays_equal(chx.index, np.array([1]))
def test__create_from_list(self): times = range(10) t_start = 0.0 t_stop = 10.0 st = SpikeTrain(times, t_start=t_start, t_stop=t_stop, units="ms") self.assertEqual(st.t_start, t_start*pq.ms) self.assertEqual(st.t_stop, t_stop*pq.ms) assert_arrays_equal(st, times*pq.ms)
def testInit(self): rcg = RecordingChannelGroup(file_origin='temp.dat', channel_indexes=np.array([1])) self.assertEqual(rcg.file_origin, 'temp.dat') self.assertEqual(rcg.name, None) self.assertEqual(rcg.recordingchannels, []) self.assertEqual(rcg.analogsignalarrays, []) assert_arrays_equal(rcg.channel_names, np.array([])) assert_arrays_equal(rcg.channel_indexes, np.array([1]))
def test_read_analogsignal_using_eager(self): io = self.io_cls(self.test_file) as3 = io.read_analogsignal(lazy=False, channel_index=3) self.assertIsInstance(as3, AnalogSignal) assert_arrays_equal( as3, AnalogSignal(numpy.arange(3, 104, dtype=float), sampling_period=0.1 * pq.ms, t_start=0 * pq.s, units=pq.mV), )
def test__recordingchannelgroup__init_defaults(self): rcg = RecordingChannelGroup() assert_neo_object_is_compliant(rcg) self.assertEqual(rcg.name, None) self.assertEqual(rcg.file_origin, None) self.assertEqual(rcg.recordingchannels, []) self.assertEqual(rcg.analogsignalarrays, []) assert_arrays_equal(rcg.channel_names, np.array([], dtype='S')) assert_arrays_equal(rcg.channel_indexes, np.array([]))
def test__compliant(self): assert_neo_object_is_compliant(self.signal1) self.assertEqual(self.signal1.name, 'spam') self.assertEqual(self.signal1.description, 'eggs') self.assertEqual(self.signal1.file_origin, 'testfile.txt') self.assertEqual(self.signal1.annotations, {'arg1': 'test'}) assert_arrays_equal(self.signal1.array_annotations['anno1'], np.array([23])) assert_arrays_equal(self.signal1.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(self.signal1.array_annotations, ArrayDict)
def test__t_stop(self): name = 't_stop' datatype = pq.Quantity targ = 1.0 * pq.millisecond res = get_fake_value(name, datatype) self.assertTrue(isinstance(res, pq.Quantity)) self.assertEqual(res.units, pq.millisecond) assert_arrays_equal(targ, res) self.assertRaises(ValueError, get_fake_value, name, datatype, dim=1) self.assertRaises(ValueError, get_fake_value, name, np.ndarray)
def test__sampling_rate(self): name = 'sampling_rate' datatype = pq.Quantity targ = 10000.0 * pq.Hz res = get_fake_value(name, datatype) self.assertTrue(isinstance(res, pq.Quantity)) self.assertEqual(res.units, pq.Hz) assert_arrays_equal(targ, res) self.assertRaises(ValueError, get_fake_value, name, datatype, dim=1) self.assertRaises(ValueError, get_fake_value, name, np.ndarray)
def test_unit_creation(self): assert_neo_object_is_compliant(self.unit1) assert_neo_object_is_compliant(self.unit2) self.assertEqual(self.unit1.name, 'test') self.assertEqual(self.unit2.name, 'test') self.assertEqual(self.unit1.description, 'tester 1') self.assertEqual(self.unit2.description, 'tester 2') self.assertEqual(self.unit1.file_origin, 'test.file') self.assertEqual(self.unit2.file_origin, 'test.file') self.assertEqual(self.unit1.annotations['testarg0'], [1, 2, 3]) self.assertEqual(self.unit2.annotations['testarg10'], [1, 2, 3]) self.assertEqual(self.unit1.annotations['testarg1'], 1.1) self.assertEqual(self.unit2.annotations['testarg1'], 1) self.assertEqual(self.unit2.annotations['testarg11'], 1.1) self.assertEqual(self.unit1.annotations['testarg2'], 'yes') self.assertEqual(self.unit2.annotations['testarg2'], 'yes') self.assertTrue(self.unit1.annotations['testarg3']) self.assertTrue(self.unit2.annotations['testarg3']) self.assertTrue(hasattr(self.unit1, 'spikes')) self.assertTrue(hasattr(self.unit2, 'spikes')) self.assertEqual(len(self.unit1.spikes), 2) self.assertEqual(len(self.unit2.spikes), 2) for res, targ in zip(self.unit1.spikes, self.spike1): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.unit2.spikes, self.spike2): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.unit1, 'spiketrains')) self.assertTrue(hasattr(self.unit2, 'spiketrains')) self.assertEqual(len(self.unit1.spiketrains), 2) self.assertEqual(len(self.unit2.spiketrains), 2) for res, targ in zip(self.unit1.spiketrains, self.train1): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.unit2.spiketrains, self.train2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name)
def test_segment_all_data(self): result1 = self.segment1.all_data targs = (self.epoch1 + self.epocharr1 + self.event1 + self.eventarr1 + self.sig1 + self.sigarr1 + self.irsig1 + self.spike1 + self.train1) for res, targ in zip(result1, targs): if hasattr(res, 'ndim') and res.ndim: assert_arrays_equal(res, targ) else: self.assertEqual(res, targ) self.assertEqual(res.name, targ.name)
def subcheck__generate_datasets(self, cls, cascade, seed=None): self.annotations['seed'] = seed if seed is None: res = fake_neo(obj_type=cls, cascade=cascade) else: res = fake_neo(obj_type=cls, cascade=cascade, seed=seed) if not hasattr(cls, 'lower'): self.assertTrue(isinstance(res, cls)) else: self.assertEqual(res.__class__.__name__, cls) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) resattr = get_fake_values(cls, annotate=False, seed=0) if seed is not None: for name, value in resattr.items(): if name in ['channel_names', 'channel_indexes', 'channel_index']: continue try: try: resvalue = getattr(res, name) except AttributeError: if name == 'signal': continue raise try: self.assertEqual(resvalue, value) except ValueError: assert_arrays_equal(resvalue, value) except BaseException as exc: exc.args += ('from %s' % name,) raise if not getattr(res, '_child_objects', ()): pass elif not cascade: self.assertEqual(res.children, ()) else: self.assertNotEqual(res.children, ()) if cls in ['RecordingChannelGroup', RecordingChannelGroup]: for i, rchan in enumerate(res.recordingchannels): self.assertEqual(rchan.name, res.channel_names[i].astype(str)) self.assertEqual(rchan.index, res.channel_indexes[i]) for i, unit in enumerate(res.units): for sigarr in res.analogsignalarrays: self.assertEqual(unit.channel_indexes[0], sigarr.channel_index[i])
def test_spike_creation(self): assert_neo_object_is_compliant(self.spike1) self.assertEqual(self.spike1.time, 1.5 * pq.ms) assert_arrays_equal(self.spike1.waveform, [[1.1, 1.5, 1.7], [2.2, 2.6, 2.8]] * pq.mV) self.assertEqual(self.spike1.sampling_rate, 0.1 * pq.Hz) self.assertEqual(self.spike1.left_sweep, 2.0 * pq.s) self.assertEqual(self.spike1.description, "tester") self.assertEqual(self.spike1.file_origin, "test.file") self.assertEqual(self.spike1.annotations["testarg0"], [1, 2, 3]) self.assertEqual(self.spike1.annotations["testarg1"], 1.1) self.assertEqual(self.spike1.annotations["testarg2"], "yes") self.assertTrue(self.spike1.annotations["testarg3"])
def test__get_fake_values(self): self.annotations['seed'] = 0 times = get_fake_value('times', pq.Quantity, seed=0, dim=1) durations = get_fake_value('durations', pq.Quantity, seed=1, dim=1) labels = get_fake_value('labels', np.ndarray, seed=2, dim=1, dtype='S') name = get_fake_value('name', str, seed=3, obj=Epoch) description = get_fake_value('description', str, seed=4, obj='Epoch') file_origin = get_fake_value('file_origin', str) attrs1 = {'name': name, 'description': description, 'file_origin': file_origin} attrs2 = attrs1.copy() attrs2.update(self.annotations) res11 = get_fake_values(Epoch, annotate=False, seed=0) res12 = get_fake_values('Epoch', annotate=False, seed=0) res21 = get_fake_values(Epoch, annotate=True, seed=0) res22 = get_fake_values('Epoch', annotate=True, seed=0) assert_arrays_equal(res11.pop('times'), times) assert_arrays_equal(res12.pop('times'), times) assert_arrays_equal(res21.pop('times'), times) assert_arrays_equal(res22.pop('times'), times) assert_arrays_equal(res11.pop('durations'), durations) assert_arrays_equal(res12.pop('durations'), durations) assert_arrays_equal(res21.pop('durations'), durations) assert_arrays_equal(res22.pop('durations'), durations) assert_arrays_equal(res11.pop('labels'), labels) assert_arrays_equal(res12.pop('labels'), labels) assert_arrays_equal(res21.pop('labels'), labels) assert_arrays_equal(res22.pop('labels'), labels) self.assertEqual(res11, attrs1) self.assertEqual(res12, attrs1) self.assertEqual(res21, attrs2) self.assertEqual(res22, attrs2)
def test__get_fake_values(self): self.annotations['seed'] = 0 signal = get_fake_value('signal', pq.Quantity, seed=0, dim=2) sampling_rate = get_fake_value('sampling_rate', pq.Quantity, seed=1, dim=0) t_start = get_fake_value('t_start', pq.Quantity, seed=2, dim=0) name = get_fake_value('name', str, seed=3, obj=AnalogSignal) description = get_fake_value('description', str, seed=4, obj='AnalogSignal') file_origin = get_fake_value('file_origin', str) arr_ann = get_fake_value('array_annotations', dict, seed=6, obj=AnalogSignal, n=4) attrs1 = { 'name': name, 'description': description, 'file_origin': file_origin } attrs2 = attrs1.copy() attrs2.update(self.annotations) attrs2['array_annotations'] = arr_ann res11 = get_fake_values(AnalogSignal, annotate=False, seed=0) res12 = get_fake_values('AnalogSignal', annotate=False, seed=0) res21 = get_fake_values(AnalogSignal, annotate=True, seed=0) res22 = get_fake_values('AnalogSignal', annotate=True, seed=0) assert_arrays_equal(res11.pop('signal'), signal) assert_arrays_equal(res12.pop('signal'), signal) assert_arrays_equal(res21.pop('signal'), signal) assert_arrays_equal(res22.pop('signal'), signal) assert_arrays_equal(res11.pop('sampling_rate'), sampling_rate) assert_arrays_equal(res12.pop('sampling_rate'), sampling_rate) assert_arrays_equal(res21.pop('sampling_rate'), sampling_rate) assert_arrays_equal(res22.pop('sampling_rate'), sampling_rate) assert_arrays_equal(res11.pop('t_start'), t_start) assert_arrays_equal(res12.pop('t_start'), t_start) assert_arrays_equal(res21.pop('t_start'), t_start) assert_arrays_equal(res22.pop('t_start'), t_start) self.assertEqual(res11, attrs1) self.assertEqual(res12, attrs1) # Array annotations need to be compared separately # because numpy arrays define equality differently arr_ann_res21 = res21.pop('array_annotations') arr_ann_attrs2 = attrs2.pop('array_annotations') self.assertEqual(res21, attrs2) assert_arrays_equal(arr_ann_res21['valid'], arr_ann_attrs2['valid']) assert_arrays_equal(arr_ann_res21['number'], arr_ann_attrs2['number']) arr_ann_res22 = res22.pop('array_annotations') self.assertEqual(res22, attrs2) assert_arrays_equal(arr_ann_res22['valid'], arr_ann_attrs2['valid']) assert_arrays_equal(arr_ann_res22['number'], arr_ann_attrs2['number'])
def test__time_shift_by_zero(self): shifted = self.evt.time_shift(0 * pq.ms) assert_arrays_equal(shifted.times, self.evt.times)
def test__get_fake_values(self): self.annotations['seed'] = 0 signal = get_fake_value('signal', pq.Quantity, seed=0, dim=2) sampling_rate = get_fake_value('sampling_rate', pq.Quantity, seed=1, dim=0) t_start = get_fake_value('t_start', pq.Quantity, seed=2, dim=0) channel_index = get_fake_value('channel_index', np.ndarray, seed=3, dim=1, dtype='i') name = get_fake_value('name', str, seed=4, obj=AnalogSignalArray) description = get_fake_value('description', str, seed=5, obj='AnalogSignalArray') file_origin = get_fake_value('file_origin', str) attrs1 = { 'name': name, 'description': description, 'file_origin': file_origin } attrs2 = attrs1.copy() attrs2.update(self.annotations) res11 = get_fake_values(AnalogSignalArray, annotate=False, seed=0) res12 = get_fake_values('AnalogSignalArray', annotate=False, seed=0) res21 = get_fake_values(AnalogSignalArray, annotate=True, seed=0) res22 = get_fake_values('AnalogSignalArray', annotate=True, seed=0) assert_arrays_equal(res11.pop('signal'), signal) assert_arrays_equal(res12.pop('signal'), signal) assert_arrays_equal(res21.pop('signal'), signal) assert_arrays_equal(res22.pop('signal'), signal) assert_arrays_equal(res11.pop('sampling_rate'), sampling_rate) assert_arrays_equal(res12.pop('sampling_rate'), sampling_rate) assert_arrays_equal(res21.pop('sampling_rate'), sampling_rate) assert_arrays_equal(res22.pop('sampling_rate'), sampling_rate) assert_arrays_equal(res11.pop('t_start'), t_start) assert_arrays_equal(res12.pop('t_start'), t_start) assert_arrays_equal(res21.pop('t_start'), t_start) assert_arrays_equal(res22.pop('t_start'), t_start) assert_arrays_equal(res11.pop('channel_index'), channel_index) assert_arrays_equal(res12.pop('channel_index'), channel_index) assert_arrays_equal(res21.pop('channel_index'), channel_index) assert_arrays_equal(res22.pop('channel_index'), channel_index) self.assertEqual(res11, attrs1) self.assertEqual(res12, attrs1) self.assertEqual(res21, attrs2) self.assertEqual(res22, attrs2)
def test__time_shift_same_units(self): shifted = self.evt.time_shift(10 * pq.ms) assert_arrays_equal(shifted.times, self.evt.times + 10 * pq.ms)
def test_merge_annotations__dict(self): self.base1.annotations = { 'val0': 'val0', 'val1': 1, 'val2': 2.2, 'val3': 'test1', 'val4': [.4], 'val5': { 0: 0, 1: { 0: 0 } }, 'val6': np.array([0, 1, 2]) } self.base2.annotations = { 'val2': 2.2, 'val3': 'test2', 'val4': [4, 4.4], 'val5': { 1: { 1: 1 }, 2: 2 }, 'val6': np.array([4, 5, 6]), 'val7': True } ann1 = self.base1.annotations ann2 = self.base2.annotations ann1c = self.base1.annotations.copy() ann2c = self.base2.annotations.copy() targ = { 'val0': 'val0', 'val1': 1, 'val2': 2.2, 'val3': 'test1;test2', 'val4': [.4, 4, 4.4], 'val5': { 0: 0, 1: { 0: 0, 1: 1 }, 2: 2 }, 'val7': True } self.base1.merge_annotations(self.base2) val6t = np.array([0, 1, 2, 4, 5, 6]) val61 = ann1.pop('val6') val61c = ann1c.pop('val6') val62 = ann2.pop('val6') val62c = ann2c.pop('val6') self.assertEqual(ann1, self.base1.annotations) self.assertNotEqual(ann1c, self.base1.annotations) self.assertEqual(ann2c, self.base2.annotations) self.assertEqual(targ, self.base1.annotations) assert_arrays_equal(val61, val6t) self.assertRaises(AssertionError, assert_arrays_equal, val61c, val6t) assert_arrays_equal(val62, val62c) self.assertEqual(self.name1, self.base1.name) self.assertEqual(self.name2, self.base2.name) self.assertEqual(self.description1, self.base1.description) self.assertEqual(self.description2, self.base2.description)
def test__get_events(self): starts_1 = Event(times=[0.5, 10.0, 25.2] * pq.s) starts_1.annotate(event_type='trial start', pick='me') starts_1.array_annotate(trial_id=[1, 2, 3]) stops_1 = Event(times=[5.5, 14.9, 30.1] * pq.s) stops_1.annotate(event_type='trial stop') stops_1.array_annotate(trial_id=[1, 2, 3]) starts_2 = Event(times=[33.2, 41.7, 52.4] * pq.s) starts_2.annotate(event_type='trial start') starts_2.array_annotate(trial_id=[4, 5, 6]) stops_2 = Event(times=[37.6, 46.1, 57.0] * pq.s) stops_2.annotate(event_type='trial stop') stops_2.array_annotate(trial_id=[4, 5, 6]) seg = Segment() seg2 = Segment() seg.events = [starts_1, stops_1] seg2.events = [starts_2, stops_2] block = Block() block.segments = [seg, seg2] # test getting one whole event via annotation extracted_starts1 = get_events(seg, event_type='trial start') extracted_starts1b = get_events(block, pick='me') self.assertEqual(len(extracted_starts1), 1) self.assertEqual(len(extracted_starts1b), 1) extracted_starts1 = extracted_starts1[0] extracted_starts1b = extracted_starts1b[0] assert_same_attributes(extracted_starts1, starts_1) assert_same_attributes(extracted_starts1b, starts_1) # test getting an empty list by searching for a non-existent property empty1 = get_events(seg, foo='bar') self.assertEqual(len(empty1), 0) # test getting an empty list by searching for a non-existent property value empty2 = get_events(seg, event_type='undefined') self.assertEqual(len(empty2), 0) # test getting only one event time of one event trial_2 = get_events(block, trial_id=2, event_type='trial start') self.assertEqual(len(trial_2), 1) trial_2 = trial_2[0] self.assertEqual(starts_1.name, trial_2.name) self.assertEqual(starts_1.description, trial_2.description) self.assertEqual(starts_1.file_origin, trial_2.file_origin) self.assertEqual(starts_1.annotations['event_type'], trial_2.annotations['event_type']) assert_arrays_equal(trial_2.array_annotations['trial_id'], np.array([2])) self.assertIsInstance(trial_2.array_annotations, ArrayDict) # test getting only one event time of more than one event trial_2b = get_events(block, trial_id=2) self.assertEqual(len(trial_2b), 2) start_idx = np.where( np.array([ev.annotations['event_type'] for ev in trial_2b]) == 'trial start')[0][0] trial_2b_start = trial_2b[start_idx] trial_2b_stop = trial_2b[start_idx - 1] assert_same_attributes(trial_2b_start, trial_2) self.assertEqual(stops_1.name, trial_2b_stop.name) self.assertEqual(stops_1.description, trial_2b_stop.description) self.assertEqual(stops_1.file_origin, trial_2b_stop.file_origin) self.assertEqual(stops_1.annotations['event_type'], trial_2b_stop.annotations['event_type']) assert_arrays_equal(trial_2b_stop.array_annotations['trial_id'], np.array([2])) self.assertIsInstance(trial_2b_stop.array_annotations, ArrayDict) # test getting more than one event time of one event trials_1_2 = get_events(block, trial_id=[1, 2], event_type='trial start') self.assertEqual(len(trials_1_2), 1) trials_1_2 = trials_1_2[0] self.assertEqual(starts_1.name, trials_1_2.name) self.assertEqual(starts_1.description, trials_1_2.description) self.assertEqual(starts_1.file_origin, trials_1_2.file_origin) self.assertEqual(starts_1.annotations['event_type'], trials_1_2.annotations['event_type']) assert_arrays_equal(trials_1_2.array_annotations['trial_id'], np.array([1, 2])) self.assertIsInstance(trials_1_2.array_annotations, ArrayDict) # test getting more than one event time of more than one event trials_1_2b = get_events(block, trial_id=[1, 2]) self.assertEqual(len(trials_1_2b), 2) start_idx = np.where( np.array([ev.annotations['event_type'] for ev in trials_1_2b]) == 'trial start')[0][0] trials_1_2b_start = trials_1_2b[start_idx] trials_1_2b_stop = trials_1_2b[start_idx - 1] assert_same_attributes(trials_1_2b_start, trials_1_2) self.assertEqual(stops_1.name, trials_1_2b_stop.name) self.assertEqual(stops_1.description, trials_1_2b_stop.description) self.assertEqual(stops_1.file_origin, trials_1_2b_stop.file_origin) self.assertEqual(stops_1.annotations['event_type'], trials_1_2b_stop.annotations['event_type']) assert_arrays_equal(trials_1_2b_stop.array_annotations['trial_id'], np.array([1, 2])) self.assertIsInstance(trials_1_2b_stop.array_annotations, ArrayDict)
def test_merge_annotations__func__dict(self): ann1 = { 'val0': 'val0', 'val1': 1, 'val2': 2.2, 'val3': 'test1', 'val4': [.4], 'val5': { 0: 0, 1: { 0: 0 } }, 'val6': np.array([0, 1, 2]) } ann2 = { 'val2': 2.2, 'val3': 'test2', 'val4': [4, 4.4], 'val5': { 1: { 1: 1 }, 2: 2 }, 'val6': np.array([4, 5, 6]), 'val7': True } ann1c = ann1.copy() ann2c = ann2.copy() targ = { 'val0': 'val0', 'val1': 1, 'val2': 2.2, 'val3': 'test1;test2', 'val4': [.4, 4, 4.4], 'val5': { 0: 0, 1: { 0: 0, 1: 1 }, 2: 2 }, 'val7': True } res = merge_annotations(ann1, ann2) val6t = np.array([0, 1, 2, 4, 5, 6]) val6r = res.pop('val6') val61 = ann1.pop('val6') val61c = ann1c.pop('val6') val62 = ann2.pop('val6') val62c = ann2c.pop('val6') self.assertEqual(ann1, ann1c) self.assertEqual(ann2, ann2c) self.assertEqual(res, targ) assert_arrays_equal(val6r, val6t) self.assertRaises(AssertionError, assert_arrays_equal, val61, val6t) assert_arrays_equal(val61, val61c) assert_arrays_equal(val62, val62c)
def test__get_epochs(self): a_1 = Epoch([0.5, 10.0, 25.2] * pq.s, durations=[5.1, 4.8, 5.0] * pq.s) a_1.annotate(epoch_type='a', pick='me') a_1.array_annotate(trial_id=[1, 2, 3]) b_1 = Epoch([5.5, 14.9, 30.1] * pq.s, durations=[4.7, 4.9, 5.2] * pq.s) b_1.annotate(epoch_type='b') b_1.array_annotate(trial_id=[1, 2, 3]) a_2 = Epoch([33.2, 41.7, 52.4] * pq.s, durations=[5.3, 5.0, 5.1] * pq.s) a_2.annotate(epoch_type='a') a_2.array_annotate(trial_id=[4, 5, 6]) b_2 = Epoch([37.6, 46.1, 57.0] * pq.s, durations=[4.9, 5.2, 5.1] * pq.s) b_2.annotate(epoch_type='b') b_2.array_annotate(trial_id=[4, 5, 6]) seg = Segment() seg2 = Segment() seg.epochs = [a_1, b_1] seg2.epochs = [a_2, b_2] block = Block() block.segments = [seg, seg2] # test getting one whole event via annotation extracted_a_1 = get_epochs(seg, epoch_type='a') extracted_a_1b = get_epochs(block, pick='me') self.assertEqual(len(extracted_a_1), 1) self.assertEqual(len(extracted_a_1b), 1) extracted_a_1 = extracted_a_1[0] extracted_a_1b = extracted_a_1b[0] assert_same_attributes(extracted_a_1, a_1) assert_same_attributes(extracted_a_1b, a_1) # test getting an empty list by searching for a non-existent property empty1 = get_epochs(seg, foo='bar') self.assertEqual(len(empty1), 0) # test getting an empty list by searching for a non-existent property value empty2 = get_epochs(seg, epoch_type='undefined') self.assertEqual(len(empty2), 0) # test getting only one event time of one event trial_2 = get_epochs(block, trial_id=2, epoch_type='a') self.assertEqual(len(trial_2), 1) trial_2 = trial_2[0] self.assertEqual(a_1.name, trial_2.name) self.assertEqual(a_1.description, trial_2.description) self.assertEqual(a_1.file_origin, trial_2.file_origin) self.assertEqual(a_1.annotations['epoch_type'], trial_2.annotations['epoch_type']) assert_arrays_equal(trial_2.array_annotations['trial_id'], np.array([2])) self.assertIsInstance(trial_2.array_annotations, ArrayDict) # test getting only one event time of more than one event trial_2b = get_epochs(block, trial_id=2) self.assertEqual(len(trial_2b), 2) a_idx = np.where( np.array([ev.annotations['epoch_type'] for ev in trial_2b]) == 'a')[0][0] trial_2b_a = trial_2b[a_idx] trial_2b_b = trial_2b[a_idx - 1] assert_same_attributes(trial_2b_a, trial_2) self.assertEqual(b_1.name, trial_2b_b.name) self.assertEqual(b_1.description, trial_2b_b.description) self.assertEqual(b_1.file_origin, trial_2b_b.file_origin) self.assertEqual(b_1.annotations['epoch_type'], trial_2b_b.annotations['epoch_type']) assert_arrays_equal(trial_2b_b.array_annotations['trial_id'], np.array([2])) self.assertIsInstance(trial_2b_b.array_annotations, ArrayDict) # test getting more than one event time of one event trials_1_2 = get_epochs(block, trial_id=[1, 2], epoch_type='a') self.assertEqual(len(trials_1_2), 1) trials_1_2 = trials_1_2[0] self.assertEqual(a_1.name, trials_1_2.name) self.assertEqual(a_1.description, trials_1_2.description) self.assertEqual(a_1.file_origin, trials_1_2.file_origin) self.assertEqual(a_1.annotations['epoch_type'], trials_1_2.annotations['epoch_type']) assert_arrays_equal(trials_1_2.array_annotations['trial_id'], np.array([1, 2])) self.assertIsInstance(trials_1_2.array_annotations, ArrayDict) # test getting more than one event time of more than one event trials_1_2b = get_epochs(block, trial_id=[1, 2]) self.assertEqual(len(trials_1_2b), 2) a_idx = np.where( np.array([ev.annotations['epoch_type'] for ev in trials_1_2b]) == 'a')[0][0] trials_1_2b_a = trials_1_2b[a_idx] trials_1_2b_b = trials_1_2b[a_idx - 1] assert_same_attributes(trials_1_2b_a, trials_1_2) self.assertEqual(b_1.name, trials_1_2b_b.name) self.assertEqual(b_1.description, trials_1_2b_b.description) self.assertEqual(b_1.file_origin, trials_1_2b_b.file_origin) self.assertEqual(b_1.annotations['epoch_type'], trials_1_2b_b.annotations['epoch_type']) assert_arrays_equal(trials_1_2b_b.array_annotations['trial_id'], np.array([1, 2])) self.assertIsInstance(trials_1_2b_b.array_annotations, ArrayDict)
def test__merge(self): self.signal1.description = None self.signal1.file_origin = None assert_neo_object_is_compliant(self.signal1) data3 = np.arange(1000.0, 1066.0).reshape((11, 6)) * pq.uV data3scale = data3.rescale(self.data1quant.units) signal2 = AnalogSignalArray(self.data1quant, sampling_rate=1*pq.kHz, channel_index=np.arange(5), name='signal2', description='test signal', file_origin='testfile.txt') signal3 = AnalogSignalArray(data3, units="uV", sampling_rate=1*pq.kHz, channel_index=np.arange(5, 11), name='signal3', description='test signal', file_origin='testfile.txt') signal4 = AnalogSignalArray(data3, units="uV", sampling_rate=1*pq.kHz, name='signal4', description='test signal', file_origin='testfile.txt') merged13 = self.signal1.merge(signal3) merged23 = signal2.merge(signal3) merged24 = signal2.merge(signal4) mergeddata13 = np.array(merged13) mergeddata23 = np.array(merged23) mergeddata24 = np.array(merged24) targdata13 = np.hstack([self.data1quant, data3scale]) targdata23 = np.hstack([self.data1quant, data3scale]) targdata24 = np.hstack([self.data1quant, data3scale]) assert_neo_object_is_compliant(signal2) assert_neo_object_is_compliant(signal3) assert_neo_object_is_compliant(merged13) assert_neo_object_is_compliant(merged23) assert_neo_object_is_compliant(merged24) self.assertEqual(merged13[0, 4], 4*pq.mV) self.assertEqual(merged23[0, 4], 4*pq.mV) self.assertEqual(merged13[0, 5], 1*pq.mV) self.assertEqual(merged23[0, 5], 1*pq.mV) self.assertEqual(merged13[10, 10], 1.065*pq.mV) self.assertEqual(merged23[10, 10], 1.065*pq.mV) self.assertEqual(merged13.t_stop, self.signal1.t_stop) self.assertEqual(merged23.t_stop, self.signal1.t_stop) self.assertEqual(merged13.name, 'merge(spam, signal3)') self.assertEqual(merged23.name, 'merge(signal2, signal3)') self.assertEqual(merged13.description, 'merge(None, test signal)') self.assertEqual(merged23.description, 'test signal') self.assertEqual(merged13.file_origin, 'merge(None, testfile.txt)') self.assertEqual(merged23.file_origin, 'testfile.txt') assert_arrays_equal(mergeddata13, targdata13) assert_arrays_equal(mergeddata23, targdata23) assert_arrays_equal(mergeddata24, targdata24) assert_arrays_equal(merged13.channel_indexes, np.arange(5, 11)) assert_arrays_equal(merged23.channel_indexes, np.arange(11)) assert_arrays_equal(merged24.channel_indexes, np.arange(5))
def test__time_shift_different_units(self): shifted = self.epc.time_shift(1 * pq.s) assert_arrays_equal(shifted.times, self.epc.times + 1000 * pq.ms)
def test_Event_merge(self): warnings.simplefilter("always") params1 = {'test2': 'y1', 'test3': True} params2 = {'test2': 'no', 'test4': False} paramstarg = {'test2': 'yes;no', 'test3': True, 'test4': False} arr_ann1 = {'index': np.arange(10, 13)} arr_ann2 = {'index': np.arange(3), 'test': ['a', 'b', 'c']} evt1 = Event( [1.1, 1.5, 1.7] * pq.ms, labels=np.array( ['test event 1 1', 'test event 1 2', 'test event 1 3'], dtype='U'), name='test', description='tester 1', file_origin='test.file', array_annotations=arr_ann1, test1=1, **params1) evt2 = Event( [2.1, 2.5, 2.7] * pq.us, labels=np.array( ['test event 2 1', 'test event 2 2', 'test event 2 3'], dtype='U'), name='test', description='tester 2', file_origin='test.file', array_annotations=arr_ann2, test1=1, **params2) evttarg = Event( [1.1, 1.5, 1.7, .0021, .0025, .0027] * pq.ms, labels=np.array([ 'test event 1 1', 'test event 1 2', 'test event 1 3', 'test event 2 1', 'test event 2 2', 'test event 2 3' ], dtype='U'), name='test', description='merge(tester 1, tester 2)', file_origin='test.file', array_annotations={'index': [10, 11, 12, 0, 1, 2]}, test1=1, **paramstarg) assert_neo_object_is_compliant(evt1) assert_neo_object_is_compliant(evt2) assert_neo_object_is_compliant(evttarg) with warnings.catch_warnings(record=True) as w: evtres = evt1.merge(evt2) self.assertEqual(len(w), 1) self.assertEqual(w[0].category, UserWarning) self.assertSequenceEqual( str(w[0].message), "The following array annotations were " "omitted, because they were only present" " in one of the merged objects: " "[] from the one that was merged " "into and ['test'] from the one that " "was merged into the other") assert_neo_object_is_compliant(evtres) assert_same_sub_schema(evttarg, evtres) # Remove this, when array_annotations are added to assert_same_sub_schema assert_arrays_equal(evtres.array_annotations['index'], np.array([10, 11, 12, 0, 1, 2])) self.assertTrue('test' not in evtres.array_annotations) self.assertIsInstance(evtres.array_annotations, ArrayDict)
def test__merge(self): self.signal1.description = None self.signal1.file_origin = None assert_neo_object_is_compliant(self.signal1) data3 = np.arange(1000.0, 1066.0).reshape((11, 6)) * pq.uV data3scale = data3.rescale(self.data1quant.units) arr_ann3 = { 'anno1': np.arange(5, 11), 'anno3': ['h', 'i', 'j', 'k', 'l', 'm'] } arr_ann4 = { 'anno1': np.arange(100, 106), 'anno3': ['o', 'p', 'q', 'r', 's', 't'] } signal2 = AnalogSignal(self.data1quant, sampling_rate=1 * pq.kHz, name='signal2', description='test signal', file_origin='testfile.txt', array_annotations=self.arr_ann1) signal3 = AnalogSignal(data3, units="uV", sampling_rate=1 * pq.kHz, name='signal3', description='test signal', file_origin='testfile.txt', array_annotations=arr_ann3) signal4 = AnalogSignal(data3, units="uV", sampling_rate=1 * pq.kHz, name='signal4', description='test signal', file_origin='testfile.txt', array_annotations=arr_ann4) with warnings.catch_warnings(record=True) as w: warnings.filterwarnings('always') merged13 = self.signal1.merge(signal3) merged23 = signal2.merge(signal3) merged24 = signal2.merge(signal4) self.assertTrue(len(w) == 3) self.assertEqual(w[-1].category, UserWarning) self.assertSequenceEqual(str(w[2].message), str(w[0].message)) self.assertSequenceEqual(str(w[2].message), str(w[1].message)) self.assertSequenceEqual( str(w[2].message), "The following array annotations were " "omitted, because they were only present" " in one of the merged objects: " "['anno2'] from the one that was merged " "into and ['anno3'] from the one that " "was merged into the other") mergeddata13 = np.array(merged13) mergeddata23 = np.array(merged23) mergeddata24 = np.array(merged24) targdata13 = np.hstack([self.data1quant, data3scale]) targdata23 = np.hstack([self.data1quant, data3scale]) targdata24 = np.hstack([self.data1quant, data3scale]) assert_neo_object_is_compliant(signal2) assert_neo_object_is_compliant(signal3) assert_neo_object_is_compliant(merged13) assert_neo_object_is_compliant(merged23) assert_neo_object_is_compliant(merged24) self.assertEqual(merged13[0, 4], 4 * pq.mV) self.assertEqual(merged23[0, 4], 4 * pq.mV) self.assertEqual(merged13[0, 5], 1 * pq.mV) self.assertEqual(merged23[0, 5], 1 * pq.mV) self.assertEqual(merged13[10, 10], 1.065 * pq.mV) self.assertEqual(merged23[10, 10], 1.065 * pq.mV) self.assertEqual(merged13.t_stop, self.signal1.t_stop) self.assertEqual(merged23.t_stop, self.signal1.t_stop) self.assertEqual(merged13.name, 'merge(spam, signal3)') self.assertEqual(merged23.name, 'merge(signal2, signal3)') self.assertEqual(merged13.description, 'merge(None, test signal)') self.assertEqual(merged23.description, 'test signal') self.assertEqual(merged13.file_origin, 'merge(None, testfile.txt)') self.assertEqual(merged23.file_origin, 'testfile.txt') assert_arrays_equal(merged13.array_annotations['anno1'], np.arange(11)) self.assertIsInstance(merged13.array_annotations, ArrayDict) self.assertNotIn('anno2', merged13.array_annotations) self.assertNotIn('anno3', merged13.array_annotations) assert_arrays_equal(merged23.array_annotations['anno1'], np.arange(11)) self.assertIsInstance(merged23.array_annotations, ArrayDict) self.assertNotIn('anno2', merged23.array_annotations) self.assertNotIn('anno3', merged23.array_annotations) assert_arrays_equal( merged24.array_annotations['anno1'], np.array([0, 1, 2, 3, 4, 100, 101, 102, 103, 104, 105])) self.assertIsInstance(merged24.array_annotations, ArrayDict) self.assertNotIn('anno2', merged24.array_annotations) self.assertNotIn('anno3', merged24.array_annotations) assert_arrays_equal(mergeddata13, targdata13) assert_arrays_equal(mergeddata23, targdata23) assert_arrays_equal(mergeddata24, targdata24)
def test_segment_merge(self): self.segment1.merge(self.segment2) self.segment1.create_many_to_one_relationship(force=True) assert_neo_object_is_compliant(self.segment1) self.assertEqual(self.segment1.name, 'test') self.assertEqual(self.segment2.name, 'test') self.assertEqual(self.segment1.description, 'tester 1') self.assertEqual(self.segment2.description, 'tester 2') self.assertEqual(self.segment1.file_origin, 'test.file') self.assertEqual(self.segment2.file_origin, 'test.file') self.assertEqual(self.segment1.annotations['testarg0'], [1, 2, 3]) self.assertEqual(self.segment2.annotations['testarg10'], [1, 2, 3]) self.assertEqual(self.segment1.annotations['testarg1'], 1.1) self.assertEqual(self.segment2.annotations['testarg1'], 1) self.assertEqual(self.segment2.annotations['testarg11'], 1.1) self.assertEqual(self.segment1.annotations['testarg2'], 'yes') self.assertEqual(self.segment2.annotations['testarg2'], 'yes') self.assertTrue(self.segment1.annotations['testarg3']) self.assertTrue(self.segment2.annotations['testarg3']) self.assertTrue(hasattr(self.segment1, 'analogsignals')) self.assertTrue(hasattr(self.segment2, 'analogsignals')) self.assertEqual(len(self.segment1.analogsignals), 4) self.assertEqual(len(self.segment2.analogsignals), 2) for res, targ in zip(self.segment1.analogsignals, self.sig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.analogsignals, self.sig2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'analogsignalarrays')) self.assertTrue(hasattr(self.segment2, 'analogsignalarrays')) self.assertEqual(len(self.segment1.analogsignalarrays), 4) self.assertEqual(len(self.segment2.analogsignalarrays), 3) for res, targ in zip(self.segment1.analogsignalarrays, self.sigarr): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.analogsignalarrays, self.sigarr2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'epochs')) self.assertTrue(hasattr(self.segment2, 'epochs')) self.assertEqual(len(self.segment1.epochs), 4) self.assertEqual(len(self.segment2.epochs), 2) for res, targ in zip(self.segment1.epochs, self.epoch): self.assertEqual(res.time, targ.time) self.assertEqual(res.duration, targ.duration) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.epochs, self.epoch2): self.assertEqual(res.time, targ.time) self.assertEqual(res.duration, targ.duration) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'epocharrays')) self.assertTrue(hasattr(self.segment2, 'epocharrays')) self.assertEqual(len(self.segment1.epocharrays), 4) self.assertEqual(len(self.segment2.epocharrays), 2) for res, targ in zip(self.segment1.epocharrays, self.epocharr): assert_arrays_equal(res.times, targ.times) assert_arrays_equal(res.durations, targ.durations) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.epocharrays, self.epocharr2): assert_arrays_equal(res.times, targ.times) assert_arrays_equal(res.durations, targ.durations) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'events')) self.assertTrue(hasattr(self.segment2, 'events')) self.assertEqual(len(self.segment1.events), 4) self.assertEqual(len(self.segment2.events), 2) for res, targ in zip(self.segment1.events, self.event): self.assertEqual(res.time, targ.time) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.events, self.event2): self.assertEqual(res.time, targ.time) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'eventarrays')) self.assertTrue(hasattr(self.segment2, 'eventarrays')) self.assertEqual(len(self.segment1.eventarrays), 4) self.assertEqual(len(self.segment2.eventarrays), 2) for res, targ in zip(self.segment1.eventarrays, self.eventarr): assert_arrays_equal(res.times, targ.times) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.eventarrays, self.eventarr2): assert_arrays_equal(res.times, targ.times) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'irregularlysampledsignals')) self.assertTrue(hasattr(self.segment2, 'irregularlysampledsignals')) self.assertEqual(len(self.segment1.irregularlysampledsignals), 4) self.assertEqual(len(self.segment2.irregularlysampledsignals), 2) for res, targ in zip(self.segment1.irregularlysampledsignals, self.irsig): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.irregularlysampledsignals, self.irsig2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'spikes')) self.assertTrue(hasattr(self.segment2, 'spikes')) self.assertEqual(len(self.segment1.spikes), 4) self.assertEqual(len(self.segment2.spikes), 2) for res, targ in zip(self.segment1.spikes, self.spike): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.spikes, self.spike2): self.assertEqual(res, targ) self.assertEqual(res.name, targ.name) self.assertTrue(hasattr(self.segment1, 'spiketrains')) self.assertTrue(hasattr(self.segment2, 'spiketrains')) self.assertEqual(len(self.segment1.spiketrains), 4) self.assertEqual(len(self.segment2.spiketrains), 2) for res, targ in zip(self.segment1.spiketrains, self.train): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name) for res, targ in zip(self.segment2.spiketrains, self.train2): assert_arrays_equal(res, targ) self.assertEqual(res.name, targ.name)
def test__get_fake_values(self): self.annotations['seed'] = 0 times = get_fake_value('times', pq.Quantity, seed=0, dim=1) labels = get_fake_value('labels', np.ndarray, seed=1, dim=1, dtype='U') name = get_fake_value('name', str, seed=2, obj=Event) description = get_fake_value('description', str, seed=3, obj='Event') file_origin = get_fake_value('file_origin', str) arr_ann = get_fake_value('array_annotations', dict, seed=5, obj=Event, n=5) attrs1 = { 'name': name, 'description': description, 'file_origin': file_origin } attrs2 = attrs1.copy() attrs2.update(self.annotations) attrs2['array_annotations'] = arr_ann res11 = get_fake_values(Event, annotate=False, seed=0) res12 = get_fake_values('Event', annotate=False, seed=0) res21 = get_fake_values(Event, annotate=True, seed=0) res22 = get_fake_values('Event', annotate=True, seed=0) assert_arrays_equal(res11.pop('times'), times) assert_arrays_equal(res12.pop('times'), times) assert_arrays_equal(res21.pop('times'), times) assert_arrays_equal(res22.pop('times'), times) assert_arrays_equal(res11.pop('labels'), labels) assert_arrays_equal(res12.pop('labels'), labels) assert_arrays_equal(res21.pop('labels'), labels) assert_arrays_equal(res22.pop('labels'), labels) self.assertEqual(res11, attrs1) self.assertEqual(res12, attrs1) # Array annotations need to be compared separately # because numpy arrays define equality differently arr_ann_res21 = res21.pop('array_annotations') arr_ann_attrs2 = attrs2.pop('array_annotations') self.assertEqual(res21, attrs2) assert_arrays_equal(arr_ann_res21['valid'], arr_ann_attrs2['valid']) assert_arrays_equal(arr_ann_res21['number'], arr_ann_attrs2['number']) arr_ann_res22 = res22.pop('array_annotations') self.assertEqual(res22, attrs2) assert_arrays_equal(arr_ann_res22['valid'], arr_ann_attrs2['valid']) assert_arrays_equal(arr_ann_res22['number'], arr_ann_attrs2['number'])