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__filter_single_annotation_nodata_container(self):
targ = [self.segs1[1], self.chxs1[1],
self.units1[1],
self.units1[3]]
res0 = self.targobj.filter(j=1,
data=False, container=True)
assert_same_sub_schema(res0, targ)
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__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'})
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__filter_single_annotation_container(self):
targ = [self.sigarrs1[1], self.irrsig1[1],
self.trains1[1], self.trains1[3],
self.units1[1]]
res0 = self.targobj.filter(j=1, container=True)
assert_same_sub_schema(res0, targ)
def test_segment_take_analogsignal_by_unit(self):
result1 = self.seg1.take_analogsignal_by_unit()
result21 = self.seg1.take_analogsignal_by_unit([self.unit1])
result22 = self.seg1.take_analogsignal_by_unit([self.unit2])
self.assertEqual(result1, [])
assert_same_sub_schema(result21, [self.sigs1a[0]])
assert_same_sub_schema(result22, [self.sigs1a[1]])
def test_segment_take_spiketrains_by_unit(self):
result1 = self.seg1.take_spiketrains_by_unit()
result21 = self.seg1.take_spiketrains_by_unit([self.unit1])
result22 = self.seg1.take_spiketrains_by_unit([self.unit2])
self.assertEqual(result1, [])
assert_same_sub_schema(result21, [self.trains1a[0]])
assert_same_sub_schema(result22, [self.trains1a[1]])
def test__merge(self):
unit1a = fake_neo(Unit, seed=self.seed1, n=self.nchildren)
assert_same_sub_schema(self.unit1, unit1a)
unit1a.annotate(seed=self.seed2)
unit1a.spiketrains.append(self.trains2[0])
unit1a.merge(self.unit2)
self.check_creation(self.unit2)
assert_same_sub_schema(self.trains1a + self.trains2,
unit1a.spiketrains)
def test_segment_take_analogsignal_by_channelindex(self):
ind1 = self.unit1.channel_indexes[0]
ind2 = self.unit2.channel_indexes[0]
result1 = self.seg1.take_analogsignal_by_channelindex()
result21 = self.seg1.take_analogsignal_by_channelindex([ind1])
result22 = self.seg1.take_analogsignal_by_channelindex([ind2])
self.assertEqual(result1, [])
assert_same_sub_schema(result21, [self.sigs1a[0]])
assert_same_sub_schema(result22, [self.sigs1a[1]])
def test__filter_single_annotation_container(self):
targ = ([self.epcs1[1], self.evts1[1]] +
self.sigarrs1[1::2] +
[self.epcs1[3], self.evts1[3]] +
self.irsigs1[1::2] +
self.trains1[1::2] +
[self.segs1[1], self.chxs1[1],
self.units1[1],
self.units1[3]])
res0 = self.targobj.filter(j=1, container=True)
assert_same_sub_schema(res0, targ)
def test_reading_same(self):
for ioobj, path in self.iter_io_objects(return_path=True):
obj_reader_base = create_generic_reader(ioobj, target=False)
obj_reader_single = create_generic_reader(ioobj)
obj_base = obj_reader_base()
obj_single = obj_reader_single()
try:
assert_same_sub_schema(obj_base, obj_single)
except BaseException as exc:
exc.args += ("from " + os.path.basename(path),)
raise
def test_seg_take_slice_of_analogsignalarray_by_unit(self):
seg = self.seg1
result1 = seg.take_slice_of_analogsignalarray_by_unit()
result21 = seg.take_slice_of_analogsignalarray_by_unit([self.unit1])
result23 = seg.take_slice_of_analogsignalarray_by_unit([self.unit3])
self.assertEqual(result1, [])
targ1 = [self.sigarrs1a[0][:, np.array([True])],
self.sigarrs1a[1][:, np.array([False])]]
targ3 = [self.sigarrs1a[0][:, np.array([False])],
self.sigarrs1a[1][:, np.array([True])]]
assert_same_sub_schema(result21, targ1)
assert_same_sub_schema(result23, targ3)
def test__rescale_same(self):
result = self.signal1.copy()
result = result.rescale(pq.nA)
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'})
self.assertEqual(result.units, 1*pq.nA)
assert_arrays_equal(result, self.data1)
assert_same_sub_schema(result, self.signal1)
def test_create(self):
"""
Create test file with signals, segments, blocks etc.
"""
iom = NeoHdf5IO(filename=self.test_file)
b1 = fake_neo() # creating a structure
iom.save(b1) # saving
# must be assigned after save
self.assertTrue(hasattr(b1, "hdf5_path"))
iom.close()
iom.connect(filename=self.test_file)
b2 = iom.get(b1.hdf5_path) # new object
assert_neo_object_is_compliant(b2)
assert_same_sub_schema(b1, b2)
def test_against_reference(self):
for filename, refname in zip(self.files_to_test,
self.files_to_compare):
if not refname:
continue
obj = self.read_file(filename=filename, readall=True)[0]
refobj = proc_src(self.get_filename_path(refname))
try:
assert_neo_object_is_compliant(obj)
assert_neo_object_is_compliant(refobj)
assert_same_sub_schema(obj, refobj)
except BaseException as exc:
exc.args += ('from ' + filename,)
raise
def test__filter_single_annotation_nores(self):
targ = []
res0 = self.targobj.filter(j=5)
res1 = self.targobj.filter({'j': 5})
res2 = self.targobj.filter(targdict={'j': 5})
res3 = self.targobj.filter([{'j': 5}])
res4 = self.targobj.filter(targdict=[{'j': 5}])
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
def test__filter_annotation_single(self):
targ = [self.trains1a[1]]
res0 = self.targobj.filter(j=1)
res1 = self.targobj.filter({'j': 1})
res2 = self.targobj.filter(targdict={'j': 1})
res3 = self.targobj.filter([{'j': 1}])
res4 = self.targobj.filter(targdict=[{'j': 1}])
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
def test_against_reference(self):
for obj, path in self.iter_objects(return_path=True):
filename = os.path.basename(path)
refpath = os.path.splitext(path)[0] + self.suffix
refobj = proc_f32(refpath)
try:
assert_neo_object_is_compliant(obj)
assert_neo_object_is_compliant(refobj)
assert_same_sub_schema(obj, refobj)
except BaseException as exc:
exc.args += ("from " + filename,)
raise
def test__filter_single_annotation_obj_single(self):
targ = [self.trains1a[1]]
res0 = self.targobj.filter(j=1, objects='SpikeTrain')
res1 = self.targobj.filter(j=1, objects=SpikeTrain)
res2 = self.targobj.filter(j=1, objects=['SpikeTrain'])
res3 = self.targobj.filter(j=1, objects=[SpikeTrain])
res4 = self.targobj.filter(j=1, objects=[SpikeTrain,
ChannelIndex])
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
def test__filter_single_annotation_obj_single(self):
targ = [self.irsigs1a[1]]
res0 = self.targobj.filter(j=1, objects='IrregularlySampledSignal')
res1 = self.targobj.filter(j=1, objects=IrregularlySampledSignal)
res2 = self.targobj.filter(j=1, objects=['IrregularlySampledSignal'])
res3 = self.targobj.filter(j=1, objects=[IrregularlySampledSignal])
res4 = self.targobj.filter(j=1, objects=[IrregularlySampledSignal,
Unit])
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
def test__rescale_same(self):
result = self.signal1.copy()
result = result.rescale(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'})
self.assertEqual(result.units, 1*pq.mV)
assert_array_equal(result.magnitude, self.data1.reshape(-1, 1))
assert_array_equal(result.times, self.time1quant)
assert_same_sub_schema(result, self.signal1)
def test__filter_single_annotation_obj_single(self):
targ = [self.epcs1a[1]]
res0 = self.targobj.filter(j=1, objects='Epoch')
res1 = self.targobj.filter(j=1, objects=Epoch)
res2 = self.targobj.filter(j=1, objects=['Epoch'])
res3 = self.targobj.filter(j=1, objects=[Epoch])
res4 = self.targobj.filter(j=1, objects=[Epoch,
ChannelIndex])
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
def test_seg_take_slice_of_analogsignalarray_by_channelindex(self):
seg = self.seg1
ind1 = self.unit1.channel_indexes[0]
ind3 = self.unit3.channel_indexes[0]
result1 = seg.take_slice_of_analogsignalarray_by_channelindex()
result21 = seg.take_slice_of_analogsignalarray_by_channelindex([ind1])
result23 = seg.take_slice_of_analogsignalarray_by_channelindex([ind3])
self.assertEqual(result1, [])
targ1 = [self.sigarrs1a[0][:, np.array([True])],
self.sigarrs1a[1][:, np.array([False])]]
targ3 = [self.sigarrs1a[0][:, np.array([False])],
self.sigarrs1a[1][:, np.array([True])]]
assert_same_sub_schema(result21, targ1)
assert_same_sub_schema(result23, targ3)
def test__time_equal(self):
t_start = 0 * pq.s
t_stop = 6 * 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'})
self.assertEqual(result.t_stop, t_stop)
self.assertEqual(result.t_start, t_start)
assert_arrays_equal(result, self.signal2)
assert_same_sub_schema(result, self.signal2)
def test_write_then_read(self):
'''
Test for IO that are able to write and read - here %s:
1 - Generate a full schema with supported objects.
2 - Write to a file
3 - Read from the file
4 - Check the hierachy
5 - Check data
Work only for IO for Block and Segment for the highest object
(main cases).
''' % self.ioclass.__name__
if not self.able_to_write_or_read(writeread=True):
return
for cascade in self.cascade_modes:
ioobj1 = self.generic_io_object(clean=True)
if ioobj1 is None:
return
ob1 = write_generic(ioobj1, target=self.higher)
close_object_safe(ioobj1)
ioobj2 = self.generic_io_object()
# Read the highest supported object from the file
obj_reader = create_generic_reader(ioobj2, target=False)
ob2 = obj_reader(cascade=cascade)[0]
if self.higher == Segment:
ob2 = ob2.segments[0]
# some formats (e.g. elphy) do not support double floating
# point spiketrains
try:
assert_same_sub_schema(ob1, ob2, True, 1e-8)
assert_neo_object_is_compliant(ob1)
assert_neo_object_is_compliant(ob2)
# intercept exceptions and add more information
except BaseException as exc:
exc.args += ('with cascade=%s ' % cascade,)
raise
close_object_safe(ioobj2)
def test__add_two_consistent_signals_should_preserve_data_complement(self):
result = self.signal1 + self.signal2
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'})
targdata = np.arange(100.0, 210.0, 2.0).reshape((11, 5))
targ = AnalogSignalArray(targdata, 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, targdata)
assert_same_sub_schema(result, targ)
def test__filter_annotation_single(self):
targ = ([self.epcs1[1], self.evts1[1]] +
self.sigarrs1[1::2] +
[self.epcs1[3], self.evts1[3]] +
self.irsigs1[1::2] +
self.trains1[1::2])
res0 = self.targobj.filter(j=1)
res1 = self.targobj.filter({'j': 1})
res2 = self.targobj.filter(targdict={'j': 1})
res3 = self.targobj.filter([{'j': 1}])
res4 = self.targobj.filter(targdict=[{'j': 1}])
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
def test__filter_annotation_single(self):
targ = (self.sigarrs1a +
[self.epcs1a[0]] +
[self.evts1a[0]] +
self.irsigs1a +
self.trains1a)
res0 = self.targobj.filter(j=0)
res1 = self.targobj.filter({'j': 0})
res2 = self.targobj.filter(targdict={'j': 0})
res3 = self.targobj.filter([{'j': 0}])
res4 = self.targobj.filter(targdict=[{'j': 0}])
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
def test_Epoch_merge(self):
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']}
epc1 = Epoch([1.1, 1.5, 1.7] * pq.ms, durations=[20, 40, 60] * pq.us,
labels=np.array(['test epoch 1 1', 'test epoch 1 2', 'test epoch 1 3'],
dtype='S'), name='test', description='tester 1',
file_origin='test.file', test1=1, array_annotations=arr_ann1, **params1)
epc2 = Epoch([2.1, 2.5, 2.7] * pq.us, durations=[3, 5, 7] * pq.ms,
labels=np.array(['test epoch 2 1', 'test epoch 2 2', 'test epoch 2 3'],
dtype='S'), name='test', description='tester 2',
file_origin='test.file', test1=1, array_annotations=arr_ann2, **params2)
epctarg = Epoch([1.1, 1.5, 1.7, .0021, .0025, .0027] * pq.ms,
durations=[20, 40, 60, 3000, 5000, 7000] * pq.us,
labels=np.array(['test epoch 1 1', 'test epoch 1 2', 'test epoch 1 3',
'test epoch 2 1', 'test epoch 2 2', 'test epoch 2 3'],
dtype='S'),
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(epc1)
assert_neo_object_is_compliant(epc2)
assert_neo_object_is_compliant(epctarg)
with warnings.catch_warnings(record=True) as w:
epcres = epc1.merge(epc2)
self.assertTrue(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(epcres)
assert_same_sub_schema(epctarg, epcres)
# Remove this, when array_annotations are added to assert_same_sub_schema
assert_arrays_equal(epcres.array_annotations['index'], np.array([10, 11, 12, 0, 1, 2]))
self.assertTrue('test' not in epcres.array_annotations)
self.assertIsInstance(epcres.array_annotations, ArrayDict)
def test__filter_multi_nores(self):
targ = []
name0 = self.spikes2[0].name
res0 = self.targobj.filter([{'j': 5}, {}])
res1 = self.targobj.filter({}, j=0)
res2 = self.targobj.filter([{}], i=0)
res3 = self.targobj.filter({'name': name0}, j=1)
res4 = self.targobj.filter(targdict={'name': name0}, j=1)
res5 = self.targobj.filter(name=name0, targdict={'j': 1})
res6 = self.targobj.filter(name=name0, j=5)
res7 = self.targobj.filter({'name': name0, 'j': 5})
res8 = self.targobj.filter(targdict={'name': name0, 'j': 5})
res9 = self.targobj.filter({'name': name0}, j=5)
res10 = self.targobj.filter(targdict={'name': name0}, j=5)
res11 = self.targobj.filter(name=name0, targdict={'j': 5})
res12 = self.targobj.filter({'name': name0}, j=5)
res13 = self.targobj.filter(targdict={'name': name0}, j=5)
res14 = self.targobj.filter(name=name0, targdict={'j': 5})
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
assert_same_sub_schema(res5, targ)
assert_same_sub_schema(res6, targ)
assert_same_sub_schema(res7, targ)
assert_same_sub_schema(res8, targ)
assert_same_sub_schema(res9, targ)
assert_same_sub_schema(res10, targ)
assert_same_sub_schema(res11, targ)
assert_same_sub_schema(res12, targ)
assert_same_sub_schema(res13, targ)
assert_same_sub_schema(res14, targ)
def test__filter_single_attribute_container_norecur(self):
targ = [self.epcs1a[1]]
res0 = self.targobj.filter(name=self.epcs1a[1].name,
container=True,
recursive=False)
assert_same_sub_schema(res0, targ)
def test__filter_single_annotation_container_norecur(self):
targ = [self.epcs1a[1], self.evts1a[1], self.img_seqs1a[1]]
res0 = self.targobj.filter(j=1, container=True, recursive=False)
assert_same_sub_schema(res0, targ)
def test__filter_single_attribute_nodata_norecur(self):
targ = []
res0 = self.targobj.filter(name=self.sigarrs1a[0].name,
data=False,
recursive=False)
assert_same_sub_schema(res0, targ)
def test__filter_single_annotation_norecur(self):
targ = [self.spikes1a[1], self.trains1a[1]]
res0 = self.targobj.filter(j=1, recursive=False)
assert_same_sub_schema(res0, targ)
def test__filterdata_multi_partres(self):
data = self.targobj.children_recur
targ = [self.epcs1a[1]]
res0 = filterdata(data, name=self.epcs1a[1].name, j=5)
res1 = filterdata(data, {'name': self.epcs1a[1].name, 'j': 5})
res2 = filterdata(data, targdict={'name': self.epcs1a[1].name, 'j': 5})
res3 = filterdata(data, [{'j': 1}, {'i': 1}])
res4 = filterdata(data, {'j': 1}, i=1)
res5 = filterdata(data, [{'j': 1}], i=1)
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
assert_same_sub_schema(res5, targ)
def test__filterdata_multi_nores(self):
data = self.targobj.children_recur
targ = []
res0 = filterdata(data, [{'j': 5}, {}])
res1 = filterdata(data, {}, ttype=0)
res2 = filterdata(data, [{}], ttype=0)
res3 = filterdata(data, {'name': self.epcs1a[1].name}, j=0)
res4 = filterdata(data, targdict={'name': self.epcs1a[1].name}, j=0)
res5 = filterdata(data, name=self.epcs1a[1].name, targdict={'j': 0})
res6 = filterdata(data, name=self.epcs2[0].name, j=5)
res7 = filterdata(data, {'name': self.epcs2[1].name, 'j': 5})
res8 = filterdata(data, targdict={'name': self.epcs2[1].name, 'j': 5})
res9 = filterdata(data, {'name': self.epcs2[1].name}, j=5)
res10 = filterdata(data, targdict={'name': self.epcs2[1].name}, j=5)
res11 = filterdata(data, name=self.epcs2[1].name, targdict={'j': 5})
res12 = filterdata(data, {'name': self.epcs1a[1].name}, j=5)
res13 = filterdata(data, targdict={'name': self.epcs1a[1].name}, j=5)
res14 = filterdata(data, name=self.epcs1a[1].name, targdict={'j': 5})
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
assert_same_sub_schema(res5, targ)
assert_same_sub_schema(res6, targ)
assert_same_sub_schema(res7, targ)
assert_same_sub_schema(res8, targ)
assert_same_sub_schema(res9, targ)
assert_same_sub_schema(res10, targ)
assert_same_sub_schema(res11, targ)
assert_same_sub_schema(res12, targ)
assert_same_sub_schema(res13, targ)
assert_same_sub_schema(res14, targ)
def test__filter_none(self):
targ = []
# collecting all data objects in target block
targ.extend(self.targobj.analogsignals)
targ.extend(self.targobj.irregularlysampledsignals)
for unit in self.targobj.units:
targ.extend(unit.spiketrains)
res1 = self.targobj.filter()
res2 = self.targobj.filter({})
res3 = self.targobj.filter([])
res4 = self.targobj.filter([{}])
res5 = self.targobj.filter([{}, {}])
res6 = self.targobj.filter([{}, {}])
res7 = self.targobj.filter(targdict={})
res8 = self.targobj.filter(targdict=[])
res9 = self.targobj.filter(targdict=[{}])
res10 = self.targobj.filter(targdict=[{}, {}])
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
assert_same_sub_schema(res5, targ)
assert_same_sub_schema(res6, targ)
assert_same_sub_schema(res7, targ)
assert_same_sub_schema(res8, targ)
assert_same_sub_schema(res9, targ)
assert_same_sub_schema(res10, targ)
def test__filter_single_annotation_nodata_norecur(self):
targ = []
res0 = self.targobj.filter(j=1, data=False, recursive=False)
assert_same_sub_schema(res0, targ)
def test__filter_single_annotation_obj_multi(self):
targ = [self.spikes1a[1], self.trains1a[1]]
res0 = self.targobj.filter(j=1, objects=['Spike', SpikeTrain])
assert_same_sub_schema(res0, targ)
def test__filter_none(self):
targ = []
res1 = self.targobj.filter()
res2 = self.targobj.filter({})
res3 = self.targobj.filter([])
res4 = self.targobj.filter([{}])
res5 = self.targobj.filter([{}, {}])
res6 = self.targobj.filter([{}, {}])
res7 = self.targobj.filter(targdict={})
res8 = self.targobj.filter(targdict=[])
res9 = self.targobj.filter(targdict=[{}])
res10 = self.targobj.filter(targdict=[{}, {}])
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
assert_same_sub_schema(res5, targ)
assert_same_sub_schema(res6, targ)
assert_same_sub_schema(res7, targ)
assert_same_sub_schema(res8, targ)
assert_same_sub_schema(res9, targ)
assert_same_sub_schema(res10, targ)
def test__filter_single_attribute_nodata(self):
targ = []
res0 = self.targobj.filter(name=self.epcs1a[1].name, data=False)
assert_same_sub_schema(res0, targ)
def test__children(self):
blk = Block(name='block1')
blk.channel_indexes = [self.chx1]
blk.create_many_to_one_relationship()
self.assertEqual(self.chx1._container_child_objects, ('Unit', ))
self.assertEqual(self.chx1._data_child_objects,
('AnalogSignal', 'IrregularlySampledSignal'))
self.assertEqual(self.chx1._single_parent_objects, ('Block', ))
self.assertEqual(self.chx1._multi_child_objects, tuple())
self.assertEqual(self.chx1._multi_parent_objects, ())
self.assertEqual(self.chx1._child_properties, ())
self.assertEqual(self.chx1._single_child_objects,
('Unit', 'AnalogSignal', 'IrregularlySampledSignal'))
self.assertEqual(self.chx1._container_child_containers, ('units', ))
self.assertEqual(self.chx1._data_child_containers,
('analogsignals', 'irregularlysampledsignals'))
self.assertEqual(
self.chx1._single_child_containers,
('units', 'analogsignals', 'irregularlysampledsignals'))
self.assertEqual(self.chx1._single_parent_containers, ('block', ))
self.assertEqual(self.chx1._multi_child_containers, tuple())
self.assertEqual(self.chx1._multi_parent_containers, ())
self.assertEqual(self.chx1._child_objects,
('Unit', 'AnalogSignal', 'IrregularlySampledSignal'))
self.assertEqual(
self.chx1._child_containers,
('units', 'analogsignals', 'irregularlysampledsignals'))
self.assertEqual(self.chx1._parent_objects, ('Block', ))
self.assertEqual(self.chx1._parent_containers, ('block', ))
self.assertEqual(len(self.chx1._single_children), 3 * self.nchildren)
self.assertEqual(len(self.chx1._multi_children), 0)
self.assertEqual(len(self.chx1.data_children), 2 * self.nchildren)
self.assertEqual(len(self.chx1.data_children_recur),
2 * self.nchildren + 1 * self.nchildren**2)
self.assertEqual(len(self.chx1.container_children), 1 * self.nchildren)
self.assertEqual(len(self.chx1.container_children_recur),
1 * self.nchildren)
self.assertEqual(len(self.chx1.children), 3 * self.nchildren)
self.assertEqual(len(self.chx1.children_recur),
3 * self.nchildren + 1 * self.nchildren**2)
assert_same_sub_schema(list(self.chx1._single_children),
self.units1a + self.sigarrs1a + self.irrsig1a,
exclude=['channel_index'])
assert_same_sub_schema(list(self.chx1.data_children),
self.sigarrs1a + self.irrsig1a,
exclude=['channel_index'])
assert_same_sub_schema(list(self.chx1.data_children_recur),
self.sigarrs1a + self.irrsig1a +
self.trains1[:2] + self.trains1[2:],
exclude=['channel_index'])
assert_same_sub_schema(list(self.chx1.children),
self.sigarrs1a + self.irrsig1a + self.units1a,
exclude=['channel_index'])
assert_same_sub_schema(list(self.chx1.children_recur),
self.sigarrs1a + self.irrsig1a +
self.trains1[:2] + self.trains1[2:] +
self.units1a,
exclude=['channel_index'])
self.assertEqual(len(self.chx1.parents), 1)
self.assertEqual(self.chx1.parents[0].name, 'block1')
def test__filter_multi_nores(self):
targ = []
res0 = self.targobj.filter([{'j': 5}, {}])
res1 = self.targobj.filter({}, ttype=6)
res2 = self.targobj.filter([{}], ttype=6)
res3 = self.targobj.filter({'name': self.epcs1a[1].name}, j=0)
res4 = self.targobj.filter(targdict={'name': self.epcs1a[1].name}, j=0)
res5 = self.targobj.filter(name=self.epcs1a[1].name, targdict={'j': 0})
res6 = self.targobj.filter(name=self.epcs2[0].name, j=5)
res7 = self.targobj.filter({'name': self.epcs2[1].name, 'j': 5})
res8 = self.targobj.filter(targdict={
'name': self.epcs2[1].name,
'j': 5
})
res9 = self.targobj.filter({'name': self.epcs2[1].name}, j=5)
res10 = self.targobj.filter(targdict={'name': self.epcs2[1].name}, j=5)
res11 = self.targobj.filter(name=self.epcs2[1].name, targdict={'j': 5})
res12 = self.targobj.filter({'name': self.epcs1a[1].name}, j=5)
res13 = self.targobj.filter(targdict={'name': self.epcs1a[1].name},
j=5)
res14 = self.targobj.filter(name=self.epcs1a[1].name,
targdict={'j': 5})
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
assert_same_sub_schema(res5, targ)
assert_same_sub_schema(res6, targ)
assert_same_sub_schema(res7, targ)
assert_same_sub_schema(res8, targ)
assert_same_sub_schema(res9, targ)
assert_same_sub_schema(res10, targ)
assert_same_sub_schema(res11, targ)
assert_same_sub_schema(res12, targ)
assert_same_sub_schema(res13, targ)
assert_same_sub_schema(res14, targ)
def test__filter_single_annotation_obj_multi(self):
targ = [self.epcs1a[1], self.evts1a[1]]
res0 = self.targobj.filter(j=1, objects=['Event', Epoch])
assert_same_sub_schema(res0, targ)
def test__children(self):
rcg = RecordingChannelGroup(name='rcg1')
rcg.units = [self.unit1]
rcg.create_many_to_one_relationship()
assert_neo_object_is_compliant(self.unit1)
assert_neo_object_is_compliant(rcg)
self.assertEqual(self.unit1._container_child_objects, ())
self.assertEqual(self.unit1._data_child_objects,
('Spike', 'SpikeTrain'))
self.assertEqual(self.unit1._single_parent_objects,
('RecordingChannelGroup',))
self.assertEqual(self.unit1._multi_child_objects, ())
self.assertEqual(self.unit1._multi_parent_objects, ())
self.assertEqual(self.unit1._child_properties, ())
self.assertEqual(self.unit1._single_child_objects,
('Spike', 'SpikeTrain'))
self.assertEqual(self.unit1._container_child_containers, ())
self.assertEqual(self.unit1._data_child_containers,
('spikes', 'spiketrains'))
self.assertEqual(self.unit1._single_child_containers,
('spikes', 'spiketrains'))
self.assertEqual(self.unit1._single_parent_containers,
('recordingchannelgroup',))
self.assertEqual(self.unit1._multi_child_containers, ())
self.assertEqual(self.unit1._multi_parent_containers, ())
self.assertEqual(self.unit1._child_objects,
('Spike', 'SpikeTrain'))
self.assertEqual(self.unit1._child_containers,
('spikes', 'spiketrains'))
self.assertEqual(self.unit1._parent_objects,
('RecordingChannelGroup',))
self.assertEqual(self.unit1._parent_containers,
('recordingchannelgroup',))
self.assertEqual(len(self.unit1._single_children), self.nchildren*2)
self.assertEqual(len(self.unit1._multi_children), 0)
self.assertEqual(len(self.unit1.data_children), self.nchildren*2)
self.assertEqual(len(self.unit1.data_children_recur), self.nchildren*2)
self.assertEqual(len(self.unit1.container_children), 0)
self.assertEqual(len(self.unit1.container_children_recur), 0)
self.assertEqual(len(self.unit1.children), self.nchildren*2)
self.assertEqual(len(self.unit1.children_recur), self.nchildren*2)
self.assertEqual(self.unit1._multi_children, ())
self.assertEqual(self.unit1.container_children, ())
self.assertEqual(self.unit1.container_children_recur, ())
assert_same_sub_schema(list(self.unit1._single_children),
self.spikes1a+self.trains1a)
assert_same_sub_schema(list(self.unit1.data_children),
self.spikes1a+self.trains1a)
assert_same_sub_schema(list(self.unit1.data_children_recur),
self.spikes1a+self.trains1a)
assert_same_sub_schema(list(self.unit1.children),
self.spikes1a+self.trains1a)
assert_same_sub_schema(list(self.unit1.children_recur),
self.spikes1a+self.trains1a)
self.assertEqual(len(self.unit1.parents), 1)
self.assertEqual(self.unit1.parents[0].name, 'rcg1')
def test__filter_multi_partres(self):
targ = [self.epcs1a[1]]
res0 = self.targobj.filter(name=self.epcs1a[1].name, j=5)
res1 = self.targobj.filter({'name': self.epcs1a[1].name, 'j': 5})
res2 = self.targobj.filter(targdict={
'name': self.epcs1a[1].name,
'j': 5
})
res3 = self.targobj.filter([{'j': 1}, {'i': 1}])
res4 = self.targobj.filter({'j': 1}, i=1)
res5 = self.targobj.filter([{'j': 1}], i=1)
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
assert_same_sub_schema(res5, targ)
def test__filter_multi_partres(self):
targ = [self.spikes1a[0]]
name = self.spikes1a[0].name
res0 = self.targobj.filter(name=name, j=5)
res1 = self.targobj.filter({'name': name, 'j': 5})
res2 = self.targobj.filter(targdict={'name': name, 'j': 5})
res3 = self.targobj.filter([{'j': 0}, {'i': 0}])
res4 = self.targobj.filter({'j': 0}, i=0)
res5 = self.targobj.filter([{'j': 0}], i=0)
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
assert_same_sub_schema(res5, targ)
def test__filter_single_attribute_nodata_container_nores(self):
targ = []
res0 = self.targobj.filter(name=self.trains1[0].name,
data=False,
container=True)
assert_same_sub_schema(res0, targ)
def test__filterdata_multi_nores(self):
data = self.targobj.children_recur
targ = []
name1 = self.sigarrs1a[0].name
name2 = self.sigarrs2[0].name
res0 = filterdata(data, [{'j': 5}, {}])
res1 = filterdata(data, {}, i=5)
res2 = filterdata(data, [{}], i=5)
res3 = filterdata(data, name=name1, targdict={'j': 1})
res4 = filterdata(data, {'name': name1}, j=1)
res5 = filterdata(data, targdict={'name': name1}, j=1)
res6 = filterdata(data, name=name2, j=5)
res7 = filterdata(data, {'name': name2, 'j': 5})
res8 = filterdata(data, targdict={'name': name2, 'j': 5})
res9 = filterdata(data, {'name': name2}, j=5)
res10 = filterdata(data, targdict={'name': name2}, j=5)
res11 = filterdata(data, name=name2, targdict={'j': 5})
res12 = filterdata(data, {'name': name1}, j=5)
res13 = filterdata(data, targdict={'name': name1}, j=5)
res14 = filterdata(data, name=name1, targdict={'j': 5})
assert_same_sub_schema(res0, targ)
assert_same_sub_schema(res1, targ)
assert_same_sub_schema(res2, targ)
assert_same_sub_schema(res3, targ)
assert_same_sub_schema(res4, targ)
assert_same_sub_schema(res5, targ)
assert_same_sub_schema(res6, targ)
assert_same_sub_schema(res7, targ)
assert_same_sub_schema(res8, targ)
assert_same_sub_schema(res9, targ)
assert_same_sub_schema(res10, targ)
assert_same_sub_schema(res11, targ)
assert_same_sub_schema(res12, targ)
assert_same_sub_schema(res13, targ)
assert_same_sub_schema(res14, targ)
def test__filter_single_annotation_container_norecur(self):
targ = [self.sigarrs1[1], self.irrsig1[1], self.units1[1]]
res0 = self.targobj.filter(j=1, container=True, recursive=False)
assert_same_sub_schema(res0, targ)
def test__filter_single_annotation_nodata_container(self):
targ = [self.units1[1]]
res0 = self.targobj.filter(j=1, data=False, container=True)
assert_same_sub_schema(res0, targ)
def test__merge(self):
seg1a = fake_neo(Block, seed=self.seed1, n=self.nchildren).segments[0]
assert_same_sub_schema(self.seg1, seg1a)
seg1a.epochs.append(self.epcs2[0])
seg1a.merge(self.seg2)
assert_same_sub_schema(self.sigarrs1a + self.sigarrs2,
seg1a.analogsignals)
assert_same_sub_schema(self.irsigs1a + self.irsigs2,
seg1a.irregularlysampledsignals)
assert_same_sub_schema(self.epcs1 + self.epcs2, seg1a.epochs)
assert_same_sub_schema(self.evts1 + self.evts2, seg1a.events)
assert_same_sub_schema(self.trains1 + self.trains2, seg1a.spiketrains)
def test__filter_single_attribute_container_data(self):
targ = [self.trains1[0]]
res0 = self.targobj.filter(name=self.trains1[0].name, container=True)
assert_same_sub_schema(res0, targ)
