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)