def test_biocam_extractor(self): path1 = self.test_dir + '/raw.brw' se.BiocamRecordingExtractor.write_recording(self.RX, path1) RX_biocam = se.BiocamRecordingExtractor(path1) check_recording_return_types(RX_biocam) check_recordings_equal(self.RX, RX_biocam) check_dumping(RX_biocam)
def test_cache_extractor(self): cache_rec = se.CacheRecordingExtractor(self.RX) check_recording_return_types(cache_rec) check_recordings_equal(self.RX, cache_rec) cache_rec.move_to('cache_rec') assert cache_rec.filename == 'cache_rec.dat' check_dumping(cache_rec, test_relative=True) cache_rec = se.CacheRecordingExtractor(self.RX, save_path='cache_rec2') check_recording_return_types(cache_rec) check_recordings_equal(self.RX, cache_rec) assert cache_rec.filename == 'cache_rec2.dat' check_dumping(cache_rec, test_relative=True) # test saving to file del cache_rec assert Path('cache_rec2.dat').is_file() # test tmp cache_rec = se.CacheRecordingExtractor(self.RX) tmp_file = cache_rec.filename del cache_rec assert not Path(tmp_file).is_file() cache_sort = se.CacheSortingExtractor(self.SX) check_sorting_return_types(cache_sort) check_sortings_equal(self.SX, cache_sort) cache_sort.move_to('cache_sort') assert cache_sort.filename == 'cache_sort.npz' check_dumping(cache_sort, test_relative=True) # test saving to file del cache_sort assert Path('cache_sort.npz').is_file() cache_sort = se.CacheSortingExtractor(self.SX, save_path='cache_sort2') check_sorting_return_types(cache_sort) check_sortings_equal(self.SX, cache_sort) assert cache_sort.filename == 'cache_sort2.npz' check_dumping(cache_sort, test_relative=True) # test saving to file del cache_sort assert Path('cache_sort2.npz').is_file() # test tmp cache_sort = se.CacheSortingExtractor(self.SX) tmp_file = cache_sort.filename del cache_sort assert not Path(tmp_file).is_file() # cleanup os.remove('cache_rec.dat') os.remove('cache_rec2.dat') os.remove('cache_sort.npz') os.remove('cache_sort2.npz')
def test_mda_extractor(self): path1 = self.test_dir + '/mda' path2 = path1 + '/firings_true.mda' se.MdaRecordingExtractor.write_recording(self.RX, path1) se.MdaSortingExtractor.write_sorting(self.SX, path2) RX_mda = se.MdaRecordingExtractor(path1) SX_mda = se.MdaSortingExtractor(path2) check_recording_return_types(RX_mda) check_recordings_equal(self.RX, RX_mda) check_sorting_return_types(SX_mda) check_sortings_equal(self.SX, SX_mda) check_dumping(RX_mda) check_dumping(SX_mda)
def test_exdir_extractors(self): path1 = self.test_dir + '/raw.exdir' se.ExdirRecordingExtractor.write_recording(self.RX, path1) RX_exdir = se.ExdirRecordingExtractor(path1) check_recording_return_types(RX_exdir) check_recordings_equal(self.RX, RX_exdir) check_dumping(RX_exdir) path2 = self.test_dir + '/firings.exdir' se.ExdirSortingExtractor.write_sorting(self.SX, path2, self.RX) SX_exdir = se.ExdirSortingExtractor(path2) check_sorting_return_types(SX_exdir) check_sortings_equal(self.SX, SX_exdir) check_dumping(SX_exdir)
def test_mearec_extractors(self): path1 = self.test_dir + '/raw.h5' se.MEArecRecordingExtractor.write_recording(self.RX, path1) RX_mearec = se.MEArecRecordingExtractor(path1) tr = RX_mearec.get_traces(channel_ids=[0, 1], end_frame=1000) check_recording_return_types(RX_mearec) check_recordings_equal(self.RX, RX_mearec) check_dumping(RX_mearec) path2 = self.test_dir + '/firings_true.h5' se.MEArecSortingExtractor.write_sorting( self.SX, path2, self.RX.get_sampling_frequency()) SX_mearec = se.MEArecSortingExtractor(path2) check_sorting_return_types(SX_mearec) check_sortings_equal(self.SX, SX_mearec) check_dumping(SX_mearec)
def test_shybrid_extractors(self): # test sorting extractor se.SHYBRIDSortingExtractor.write_sorting(self.SX, self.test_dir) initial_sorting_file = os.path.join(self.test_dir, 'initial_sorting.csv') SX_shybrid = se.SHYBRIDSortingExtractor(initial_sorting_file) check_sorting_return_types(SX_shybrid) check_sortings_equal(self.SX, SX_shybrid) check_dumping(SX_shybrid) # test recording extractor se.SHYBRIDRecordingExtractor.write_recording(self.RX, self.test_dir, initial_sorting_file) RX_shybrid = se.SHYBRIDRecordingExtractor( os.path.join(self.test_dir, 'recording.bin')) check_recording_return_types(RX_shybrid) check_recordings_equal(self.RX, RX_shybrid) check_dumping(RX_shybrid)
def test_nixio_extractor(self): path1 = os.path.join(self.test_dir, 'raw.nix') se.NIXIORecordingExtractor.write_recording(self.RX, path1) RX_nixio = se.NIXIORecordingExtractor(path1) check_recording_return_types(RX_nixio) check_recordings_equal(self.RX, RX_nixio) check_dumping(RX_nixio) del RX_nixio # test force overwrite se.NIXIORecordingExtractor.write_recording(self.RX, path1, overwrite=True) path2 = self.test_dir + '/firings_true.nix' se.NIXIOSortingExtractor.write_sorting(self.SX, path2) SX_nixio = se.NIXIOSortingExtractor(path2) check_sorting_return_types(SX_nixio) check_sortings_equal(self.SX, SX_nixio) check_dumping(SX_nixio)
def test_write_recording(self): path = self.test_dir + '/test.nwb' write_recording(self.RX, path) RX_nwb = se.NwbRecordingExtractor(path) check_recording_return_types(RX_nwb) check_recordings_equal(self.RX, RX_nwb) check_dumping(RX_nwb) del RX_nwb write_recording(recording=self.RX, save_path=path, overwrite=True) RX_nwb = se.NwbRecordingExtractor(path) check_recording_return_types(RX_nwb) check_recordings_equal(self.RX, RX_nwb) check_dumping(RX_nwb) # Writing multiple recordings using metadata metadata = get_default_nwbfile_metadata() path_multi = self.test_dir + '/test_multiple.nwb' write_recording( recording=self.RX, save_path=path_multi, metadata=metadata, write_as='raw', es_key='ElectricalSeries_raw', ) write_recording( recording=self.RX2, save_path=path_multi, metadata=metadata, write_as='processed', es_key='ElectricalSeries_processed', ) write_recording( recording=self.RX3, save_path=path_multi, metadata=metadata, write_as='lfp', es_key='ElectricalSeries_lfp', ) RX_nwb = se.NwbRecordingExtractor(file_path=path_multi, electrical_series_name='raw_traces') check_recording_return_types(RX_nwb) check_recordings_equal(self.RX, RX_nwb) check_dumping(RX_nwb) del RX_nwb
def test_neuroscope_extractors(self): # NeuroscopeRecordingExtractor tests nscope_dir = Path(self.test_dir) / 'neuroscope_rec0' dat_file = nscope_dir / 'neuroscope_rec0.dat' se.NeuroscopeRecordingExtractor.write_recording(self.RX, nscope_dir) RX_ns = se.NeuroscopeRecordingExtractor(dat_file) check_recording_return_types(RX_ns) check_recordings_equal(self.RX, RX_ns, force_dtype='int32') check_dumping(RX_ns) check_recording_return_types(RX_ns) check_recordings_equal(self.RX, RX_ns, force_dtype='int32') check_dumping(RX_ns) del RX_ns # overwrite nscope_dir = Path(self.test_dir) / 'neuroscope_rec1' dat_file = nscope_dir / 'neuroscope_rec1.dat' se.NeuroscopeRecordingExtractor.write_recording(recording=self.RX, save_path=nscope_dir) RX_ns = se.NeuroscopeRecordingExtractor(dat_file) check_recording_return_types(RX_ns) check_recordings_equal(self.RX, RX_ns) check_dumping(RX_ns) # NeuroscopeMultiRecordingTimeExtractor tests nscope_dir = Path(self.test_dir) / "neuroscope_rec2" dat_file = nscope_dir / "neuroscope_rec2.dat" RX_multirecording = se.MultiRecordingTimeExtractor( recordings=[self.RX, self.RX]) se.NeuroscopeMultiRecordingTimeExtractor.write_recording( recording=RX_multirecording, save_path=nscope_dir) RX_mre = se.NeuroscopeMultiRecordingTimeExtractor( folder_path=nscope_dir) check_recording_return_types(RX_mre) check_recordings_equal(RX_multirecording, RX_mre) check_dumping(RX_mre) # NeuroscopeSortingExtractor tests nscope_dir = Path(self.test_dir) / 'neuroscope_sort0' sort_name = 'neuroscope_sort0' initial_sorting_resfile = Path( self.test_dir) / sort_name / f'{sort_name}.res' initial_sorting_clufile = Path( self.test_dir) / sort_name / f'{sort_name}.clu' se.NeuroscopeSortingExtractor.write_sorting(self.SX, nscope_dir) SX_neuroscope = se.NeuroscopeSortingExtractor( resfile_path=initial_sorting_resfile, clufile_path=initial_sorting_clufile) check_sorting_return_types(SX_neuroscope) check_sortings_equal(self.SX, SX_neuroscope) check_dumping(SX_neuroscope) SX_neuroscope_no_mua = se.NeuroscopeSortingExtractor( resfile_path=initial_sorting_resfile, clufile_path=initial_sorting_clufile, keep_mua_units=False) check_sorting_return_types(SX_neuroscope_no_mua) check_dumping(SX_neuroscope_no_mua) # Test for extra argument 'keep_mua_units' resulted in the right output SX_neuroscope_no_mua = se.NeuroscopeSortingExtractor( resfile_path=initial_sorting_resfile, clufile_path=initial_sorting_clufile, keep_mua_units=False) check_sorting_return_types(SX_neuroscope_no_mua) check_dumping(SX_neuroscope_no_mua) num_original_units = len(SX_neuroscope.get_unit_ids()) self.assertEqual(list(SX_neuroscope.get_unit_ids()), list(range(1, num_original_units + 1))) self.assertEqual(list(SX_neuroscope_no_mua.get_unit_ids()), list(range(1, num_original_units))) # Tests for the auto-detection of format for NeuroscopeSortingExtractor SX_neuroscope_from_fp = se.NeuroscopeSortingExtractor( folder_path=nscope_dir) check_sorting_return_types(SX_neuroscope_from_fp) check_sortings_equal(self.SX, SX_neuroscope_from_fp) check_dumping(SX_neuroscope_from_fp) # Tests for the NeuroscopeMultiSortingExtractor nscope_dir = Path(self.test_dir) / 'neuroscope_sort1' SX_multisorting = se.MultiSortingExtractor(sortings=[self.SX, self.SX]) se.NeuroscopeMultiSortingExtractor.write_sorting( SX_multisorting, nscope_dir) SX_neuroscope_mse = se.NeuroscopeMultiSortingExtractor(nscope_dir) check_sorting_return_types(SX_neuroscope_mse) check_sortings_equal(SX_multisorting, SX_neuroscope_mse) check_dumping(SX_neuroscope_mse)
def test_nwb_extractor(self): path1 = self.test_dir + '/test.nwb' se.NwbRecordingExtractor.write_recording(self.RX, path1) RX_nwb = se.NwbRecordingExtractor(path1) check_recording_return_types(RX_nwb) check_recordings_equal(self.RX, RX_nwb) check_dumping(RX_nwb) del RX_nwb se.NwbRecordingExtractor.write_recording(recording=self.RX, save_path=path1, overwrite=True) RX_nwb = se.NwbRecordingExtractor(path1) check_recording_return_types(RX_nwb) check_recordings_equal(self.RX, RX_nwb) check_dumping(RX_nwb) # append sorting to existing file se.NwbSortingExtractor.write_sorting(sorting=self.SX, save_path=path1, overwrite=False) path2 = self.test_dir + "/firings_true.nwb" se.NwbRecordingExtractor.write_recording(recording=self.RX, save_path=path2) se.NwbSortingExtractor.write_sorting(sorting=self.SX, save_path=path2) SX_nwb = se.NwbSortingExtractor(path2) check_sortings_equal(self.SX, SX_nwb) check_dumping(SX_nwb) # Test for handling unit property descriptions argument property_descriptions = dict( stability="This is a description of stability.") se.NwbRecordingExtractor.write_recording(recording=self.RX, save_path=path1, overwrite=True) se.NwbSortingExtractor.write_sorting( sorting=self.SX, save_path=path1, property_descriptions=property_descriptions) SX_nwb = se.NwbSortingExtractor(path1) check_sortings_equal(self.SX, SX_nwb) check_dumping(SX_nwb) # Test for handling skip_properties argument se.NwbRecordingExtractor.write_recording(recording=self.RX, save_path=path1, overwrite=True) se.NwbSortingExtractor.write_sorting(sorting=self.SX, save_path=path1, skip_properties=['stability']) SX_nwb = se.NwbSortingExtractor(path1) assert 'stability' not in SX_nwb.get_shared_unit_property_names() check_sortings_equal(self.SX, SX_nwb) check_dumping(SX_nwb) # Test for handling skip_features argument se.NwbRecordingExtractor.write_recording(recording=self.RX, save_path=path1, overwrite=True) # SX2 has timestamps, so loading it back from Nwb will not recover the same spike frames. USe use_times=False se.NwbSortingExtractor.write_sorting(sorting=self.SX2, save_path=path1, skip_features=['widths'], use_times=False) SX_nwb = se.NwbSortingExtractor(path1) assert 'widths' not in SX_nwb.get_shared_unit_spike_feature_names() check_sortings_equal(self.SX2, SX_nwb) check_dumping(SX_nwb) # Test writting multiple recordings using metadata metadata = get_default_nwbfile_metadata() path_nwb = self.test_dir + '/test_multiple.nwb' se.NwbRecordingExtractor.write_recording( recording=self.RX, save_path=path_nwb, metadata=metadata, write_as='raw', es_key='ElectricalSeries_raw', ) se.NwbRecordingExtractor.write_recording( recording=self.RX2, save_path=path_nwb, metadata=metadata, write_as='processed', es_key='ElectricalSeries_processed', ) se.NwbRecordingExtractor.write_recording( recording=self.RX3, save_path=path_nwb, metadata=metadata, write_as='lfp', es_key='ElectricalSeries_lfp', ) RX_nwb = se.NwbRecordingExtractor(file_path=path_nwb, electrical_series_name='raw_traces') check_recording_return_types(RX_nwb) check_recordings_equal(self.RX, RX_nwb) check_dumping(RX_nwb) del RX_nwb
def test_example(self): self.assertEqual(self.RX.get_channel_ids(), self.example_info['channel_ids']) self.assertEqual(self.RX.get_num_channels(), self.example_info['num_channels']) self.assertEqual(self.RX.get_num_frames(), self.example_info['num_frames']) self.assertEqual(self.RX.get_sampling_frequency(), self.example_info['sampling_frequency']) self.assertEqual(self.SX.get_unit_ids(), self.example_info['unit_ids']) self.assertEqual( self.RX.get_channel_locations(0)[0][0], self.example_info['channel_prop'][0]) self.assertEqual( self.RX.get_channel_locations(0)[0][1], self.example_info['channel_prop'][1]) self.assertTrue( np.array_equal(self.RX.get_ttl_events()[0], self.example_info['ttls'])) self.assertEqual( self.SX.get_unit_property(unit_id=1, property_name='stability'), self.example_info['unit_prop']) self.assertTrue( np.array_equal(self.SX.get_unit_spike_train(1), self.example_info['train1'])) self.assertTrue( issubclass(self.SX.get_unit_spike_train(1).dtype.type, np.integer)) self.assertTrue(self.RX.get_shared_channel_property_names(), ['group', 'location', 'shared_channel_prop']) self.assertTrue(self.RX.get_channel_property_names(0), ['group', 'location', 'shared_channel_prop']) self.assertTrue(self.SX2.get_shared_unit_property_names(), ['shared_unit_prop']) self.assertTrue(self.SX2.get_unit_property_names(4), ['shared_unit_prop', 'stability']) self.assertTrue(self.SX2.get_shared_unit_spike_feature_names(), ['shared_unit_feature']) self.assertTrue(self.SX2.get_unit_spike_feature_names(3), ['shared_channel_prop', 'widths']) self.assertTrue( np.array_equal(self.SX3.get_unit_spike_features(0, 'dummy'), self.example_info['features3'])) self.assertTrue( np.array_equal( self.SX3.get_unit_spike_features(0, 'dummy', start_frame=4), self.example_info['features3'][1:])) self.assertTrue( np.array_equal( self.SX3.get_unit_spike_features(0, 'dummy', end_frame=4), self.example_info['features3'][:1])) self.assertTrue( np.array_equal( self.SX3.get_unit_spike_features(0, 'dummy', start_frame=20, end_frame=46), self.example_info['features3'][1:6])) self.assertTrue('dummy2' in self.SX3.get_unit_spike_feature_names(0)) self.assertTrue( 'dummy2_idxs' in self.SX3.get_unit_spike_feature_names(0)) sub_extractor_full = se.SubSortingExtractor(self.SX3) sub_extractor_partial = se.SubSortingExtractor(self.SX3, start_frame=20, end_frame=46) self.assertTrue( np.array_equal( sub_extractor_full.get_unit_spike_features(0, 'dummy'), self.SX3.get_unit_spike_features(0, 'dummy'))) self.assertTrue( np.array_equal( sub_extractor_partial.get_unit_spike_features(0, 'dummy'), self.SX3.get_unit_spike_features(0, 'dummy', start_frame=20, end_frame=46))) self.assertEqual(tuple(self.RX.get_epoch_info("epoch1").values()), self.example_info['epochs_info'][0]) self.assertEqual(tuple(self.RX.get_epoch_info("epoch2").values()), self.example_info['epochs_info'][1]) self.assertEqual(tuple(self.SX.get_epoch_info("epoch1").values()), self.example_info['epochs_info'][0]) self.assertEqual(tuple(self.SX.get_epoch_info("epoch2").values()), self.example_info['epochs_info'][1]) self.assertEqual(tuple(self.RX.get_epoch_info("epoch1").values()), tuple(self.RX2.get_epoch_info("epoch1").values())) self.assertEqual(tuple(self.RX.get_epoch_info("epoch2").values()), tuple(self.RX2.get_epoch_info("epoch2").values())) self.assertEqual(tuple(self.SX.get_epoch_info("epoch1").values()), tuple(self.SX2.get_epoch_info("epoch1").values())) self.assertEqual(tuple(self.SX.get_epoch_info("epoch2").values()), tuple(self.SX2.get_epoch_info("epoch2").values())) self.assertTrue( np.array_equal( self.RX2.frame_to_time(np.arange(self.RX2.get_num_frames())), self.example_info['times'])) self.assertTrue( np.array_equal( self.SX2.get_unit_spike_train(3) / self.SX2.get_sampling_frequency() + 5, self.SX2.frame_to_time(self.SX2.get_unit_spike_train(3)))) self.RX3.clear_channel_locations() self.assertTrue( 'location' not in self.RX3.get_shared_channel_property_names()) self.RX3.set_channel_locations(self.example_info['geom']) self.assertTrue( np.array_equal(self.RX3.get_channel_locations(), self.RX2.get_channel_locations())) self.RX3.set_channel_groups(groups=[1], channel_ids=[1]) self.assertEqual(self.RX3.get_channel_groups(channel_ids=[1]), 1) self.RX3.clear_channel_groups() self.assertEqual(self.RX3.get_channel_groups(channel_ids=[1]), 0) self.RX3.set_channel_locations(locations=[[np.nan, np.nan, np.nan]], channel_ids=[1]) self.assertTrue( 'location' not in self.RX3.get_shared_channel_property_names()) self.RX3.set_channel_locations(locations=[[0, 0, 0]], channel_ids=[1]) self.assertTrue( 'location' in self.RX3.get_shared_channel_property_names()) check_recording_return_types(self.RX)