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'])
