def test_errors(self): """ some tests for specific errors """ f = open("thisisafakehdf.h5", "w") # wrong file type f.write("this is not an HDF5 file. sorry.") f.close() self.assertRaises(TypeError, NeoHdf5IO(filename="thisisafakehdf.h5")) iom = NeoHdf5IO(filename=self.test_file) # wrong object path test self.assertRaises(LookupError, iom.get("/wrong_path")) some_object = np.array([1, 2, 3]) # non NEO object test self.assertRaises(AssertionError, iom.save(some_object))
def test_relations(self): """ make sure the change in relationships is saved properly in the file, including correct M2M, no redundancy etc. RC -> RCG not tested.""" def assert_children(self, obj, replica): obj_type = name_by_class[obj] self.assertEqual( md5(str(obj)).hexdigest(), md5(str(replica)).hexdigest()) if one_to_many_relationship.has_key(obj_type): rels = one_to_many_relationship[obj_type] if obj_type == "RecordingChannelGroup": rels += many_to_many_relationship[obj_type] for child_type in rels: ch1 = getattr(obj, child_type.lower() + "s") ch2 = getattr(replica, child_type.lower() + "s") self.assertEqual(len(ch1), len(ch2)) for i, v in enumerate(ch1): self.assert_children(ch1[i], ch2[i]) iom = NeoHdf5IO(filename=self.test_file) for obj_type in class_by_name.keys(): obj = fake_NEO(obj_type, cascade=True) iom.save(obj) self.assertTrue(hasattr(obj, "hdf5_path")) replica = iom.get(obj.hdf5_path, cascade=True) self.assert_children(obj, replica)
def test_property_change(self): """ Make sure all attributes are saved properly after the change, including quantities, units, types etc.""" iom = NeoHdf5IO(filename=self.test_file) for obj_type in class_by_name.keys(): obj = fake_NEO(obj_type, cascade=False) iom.save(obj) self.assertTrue(hasattr(obj, "hdf5_path")) replica = iom.get(obj.hdf5_path, cascade=False) assert_objects_equivalent(obj, replica)
def __init__(self): # Initialize for loading the spike train data from storage collab_path = '/3653' client = get_bbp_client().document # Load NEST data using NeoHdf5I0 store_path = "./local" client.download_file(collab_path + '/' + "spikes_L6I_spinnaker.h5", store_path + "spikes_L6I_spinnaker.h5") data = NeoHdf5IO(store_path + "spikes_L6I_spinnaker.h5") self.spiketrains = data.read_block().list_children_by_class(SpikeTrain)
def test_store_empty_spike_train(self): spiketrain0 = SpikeTrain([], t_start=0.0, t_stop=100.0, units="ms") spiketrain1 = SpikeTrain([23.4, 45.6, 67.8], t_start=0.0, t_stop=100.0, units="ms") segment = Segment(name="a_segment") segment.spiketrains.append(spiketrain0) segment.spiketrains.append(spiketrain1) block = Block(name="a_block") block.segments.append(segment) iom = NeoHdf5IO(filename="test987.h5") iom.save(block) iom.close() iom = NeoHdf5IO(filename="test987.h5") block1 = iom.get("/Block_0") self.assertEqual(block1.segments[0].spiketrains[0].t_stop, 100.0) self.assertEqual(len(block1.segments[0].spiketrains[0]), 0) self.assertEqual(len(block1.segments[0].spiketrains[1]), 3) iom.close() os.remove("test987.h5")
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 self.assertTrue(hasattr(b1, "hdf5_path")) # must be assigned after save 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_attr_changes(self): """ gets an object, changes its attributes, saves it, then compares how good the changes were saved. """ iom = NeoHdf5IO(filename=self.test_file) for obj_type in objectnames: obj = fake_neo(obj_type=obj_type, cascade=False) iom.save(obj) orig_obj = iom.get(obj.hdf5_path) for attr in obj._all_attrs: if hasattr(orig_obj, attr[0]): setattr(obj, attr[0], get_fake_value(*attr)) iom.save(orig_obj) test_obj = iom.get(orig_obj.hdf5_path) assert_objects_equivalent(orig_obj, test_obj)
def test_attr_changes(self): """ gets an object, changes its attributes, saves it, then compares how good the changes were saved. """ iom = NeoHdf5IO(filename=self.test_file) for obj_type in class_by_name.keys(): obj = fake_NEO(obj_type=obj_type, cascade=False) iom.save(obj) orig_obj = iom.get(obj.hdf5_path) attrs = classes_necessary_attributes[ obj_type] + classes_recommended_attributes[obj_type] for attr in attrs: if hasattr(orig_obj, attr[0]): setattr(obj, attr[0], get_fake_value(attr)) iom.save(orig_obj) test_obj = iom.get(orig_obj.hdf5_path) assert_objects_equivalent(orig_obj, test_obj)
def load(self): # load the data iom = NeoHdf5IO(filename=self.parameters.root_directory + "/datastore.hdf5") self.block = iom.get("/block_0") # re-wrap segments new = [] for s in self.block.segments: new.append(MozaikSegment(s)) self.block.segments = new # now just construct the stimulus dictionary for s in self.block.segments: self.stimulus_dict[s.stimulus] = True self.analysis_results = load_pickle_crosscompat(self.parameters.root_directory + "/datastore.analysis.pickle")
def save(self): # we need to first unwrap segments from MozaikWrapper old = self.block.segments[:] self.block.segments = [] for s in old: self.block.segments.append(s.original_segment) # save the recording itself iom = NeoHdf5IO(filename=self.parameters.root_directory + "/datastore.hdf5") iom.write_block(self.block) # put back wrapped segments self.block.segments = old f = open(self.parameters.root_directory + "/datastore.analysis.pickle", "wb") # pickle.dump(self.analysis_results, f) cPickle.dump(self.analysis_results, f) f.close()
def test_relations(self): """ make sure the change in relationships is saved properly in the file, including correct M2M, no redundancy etc. RC -> RCG not tested. """ def assert_children(self, obj, replica): obj_type = obj.__name__ self.assertEqual(md5(str(obj)).hexdigest(), md5(str(replica)).hexdigest()) for container in getattr(obj, '_child_containers', []): ch1 = getattr(obj, container) ch2 = getattr(replica, container) self.assertEqual(len(ch1), len(ch2)) for i, v in enumerate(ch1): self.assert_children(ch1[i], ch2[i]) iom = NeoHdf5IO(filename=self.test_file) for obj_type in objectnames: obj = fake_neo(obj_type, cascade=True) iom.save(obj) self.assertTrue(hasattr(obj, "hdf5_path")) replica = iom.get(obj.hdf5_path, cascade=True) self.assert_children(obj, replica)
for key in pos_group: spot_group = pos_group[key] times = spot_group["timestamps"] coords = spot_group["data"] irr_signal = IrregularlySampledSignal( name=pos_group[key].name, signal=coords.data, times=times.data, units=coords.attrs["unit"], time_units=times.attrs["unit"]) irr_signals.append(irr_signal) return irr_signals if __name__ == "__main__": import sys testfile = "/tmp/test.exdir" io = ExdirIO(testfile) block = io.read_block() from neo.io.hdf5io import NeoHdf5IO testfile = "/tmp/test_exdir_to_neo.h5" try: os.remove(testfile) except: pass hdf5io = NeoHdf5IO(testfile) hdf5io.write(block)
def test_read_with_merge(self): test_file = get_test_file_full_path(self.ioclass, filename=self.files_to_test[0], directory=self.local_test_dir, clean=False) io = NeoHdf5IO(test_file) blocks = io.read_all_blocks(merge_singles=True) # general tests, true for both blocks for block in blocks: for segment in block.segments: self.assertEqual(segment.block, block) # tests of Block #1, which is constructed from "array" (multi-channel) # objects, so should be straightforward to convert to the version 0.5 API block0 = blocks[0] self.assertEqual(block0.name, "block1") self.assertEqual(block0.index, 1234) self.assertEqual(block0.annotations["foo"], "bar") self.assertEqual(len(block0.segments), 3) for segment in block0.segments: self.assertEqual(len(segment.analogsignals), 2) as0 = segment.analogsignals[0] self.assertEqual(as0.shape, (1000, 4)) self.assertEqual(as0.sampling_rate, 1 * kHz) self.assertEqual(as0.units, mV) self.assertEqual(as0.segment, segment) self.assertEqual(len(segment.spiketrains), 4) st = segment.spiketrains[-1] self.assertEqual(st.units, ms) self.assertEqual(st.t_stop, 1000 * ms) self.assertEqual(st.t_start, 0 * ms) self.assertEqual(st.segment, segment) self.assertEqual(len(segment.events), 1) ev = segment.events[0] assert_array_equal(ev.labels, np.array(['trig0', 'trig1', 'trig2'])) self.assertEqual(ev.units, second) assert_array_equal(ev.magnitude, np.arange(0, 30, 10)) self.assertEqual(ev.segment, segment) self.assertEqual(len(segment.epochs), 1) ep = segment.epochs[0] assert_array_equal(ep.labels, np.array(['btn0', 'btn1', 'btn2'])) assert_array_equal(ep.durations.magnitude, np.array([10, 5, 7])) self.assertEqual(ep.units, second) assert_array_equal(ep.magnitude, np.arange(0, 30, 10)) self.assertEqual(ep.segment, segment) self.assertEqual(len(segment.irregularlysampledsignals), 2) iss0 = segment.irregularlysampledsignals[0] self.assertEqual(iss0.shape, (3, 2)) assert_array_equal(iss0.times, [0.01, 0.03, 0.12] * second) assert_array_equal(iss0.magnitude, np.array([[4, 3], [5, 4], [6, 3]])) self.assertEqual(iss0.units, nA) self.assertEqual(iss0.segment, segment) iss1 = segment.irregularlysampledsignals[1] self.assertEqual(iss1.shape, (3, 1)) assert_array_equal(iss1.times, [0.02, 0.05, 0.15] * second) self.assertEqual(iss1.units, nA) assert_array_equal(iss1.magnitude, np.array([[3], [4], [3]])) # tests of Block #2, which is constructed from "singleton" # (single-channel) objects, so is potentially tricky to convert to the # version 0.5 API block1 = blocks[1] self.assertEqual(block1.name, "block2") for segment in block1.segments: self.assertEqual(len(segment.analogsignals), 2) as0 = segment.analogsignals[0] self.assertEqual(as0.shape, (1000, 4)) self.assertEqual(as0.sampling_rate, 1 * kHz) self.assertEqual(as0.units, mV) self.assertEqual(as0.segment, segment) self.assertEqual(len(segment.spiketrains), 7) st = segment.spiketrains[-1] self.assertEqual(st.units, ms) self.assertEqual(st.t_stop, 1000 * ms) self.assertEqual(st.t_start, 0 * ms) self.assertEqual(st.segment, segment) self.assertEqual(len(segment.events), 0) self.assertEqual(len(segment.epochs), 0) self.assertEqual(len(block1.channel_indexes), 3) ci0 = block1.channel_indexes[0] self.assertEqual(ci0.name, "electrode1") self.assertEqual(len(ci0.analogsignals), 1) as00 = ci0.analogsignals[0] self.assertEqual(as00.segment, segment) self.assertEqual(as00.shape, (1000, 4)) self.assertEqual(id(as00), id(segment.analogsignals[0])) self.assertEqual(as00.mean(), segment.analogsignals[0].mean()) self.assertEqual(as00.channel_index, ci0) assert_array_equal(ci0.index, np.array([0, 1, 2, 3])) assert_array_equal(ci0.channel_ids, np.array([0, 1, 2, 3])) self.assertEqual(len(ci0.units), 2) self.assertEqual(len(ci0.units[0].spiketrains), 2) self.assertEqual(id(ci0.units[0].spiketrains[0]), id(block1.segments[0].spiketrains[0])) self.assertEqual(id(ci0.units[0].spiketrains[1]), id(block1.segments[1].spiketrains[0])) self.assertEqual(id(ci0.units[1].spiketrains[0]), id(block1.segments[0].spiketrains[1])) ci1 = block1.channel_indexes[1] self.assertEqual(ci1.name, "electrode2") self.assertEqual(len(ci1.analogsignals), 1) as10 = ci1.analogsignals[0] self.assertEqual(as10.segment, segment) self.assertEqual(as10.shape, (1000, 4)) self.assertEqual(id(as10), id(segment.analogsignals[1])) self.assertEqual(as10.mean(), segment.analogsignals[1].mean()) self.assertEqual(as10.channel_index, ci1) assert_array_equal(ci1.index, np.array([0, 1, 2, 3])) assert_array_equal(ci1.channel_ids, np.array([4, 5, 6, 7])) self.assertEqual(len(ci1.units), 5) self.assertEqual(id(ci1.units[0].spiketrains[0]), id(block1.segments[0].spiketrains[2])) self.assertEqual(id(ci1.units[3].spiketrains[1]), id(block1.segments[1].spiketrains[5])) ci2 = block1.channel_indexes[2] self.assertEqual(ci2.name, "my_favourite_channels") self.assertEqual(len(ci2.analogsignals), 1) self.assertEqual(id(ci2.analogsignals[0]), id(as00)) assert_array_equal(ci2.index, np.array([1, 3])) assert_array_equal(ci2.channel_ids, np.array([1, 3]))
# TODO what if read_analogsignal is called twice? The channel_index list should be cleared at some point channel_index = self._channel_to_channel_index[ eeg_original_channel_id] channel_index.analogsignals.append(analog_signal) analog_signals.append(analog_signal) return analog_signals if __name__ == "__main__": import sys # import quantities io = AxonaIO(sys.argv[1]) # io.read_analogsignal() # io.read_spiketrain() # io.read_spiketrainlist() # io.read_tracking() block = io.read_block() from neo.io.hdf5io import NeoHdf5IO testfile = "/tmp/test.h5" try: os.remove("/tmp/test.h5") except: pass hdf5io = NeoHdf5IO("/tmp/test.h5") hdf5io.write(block)