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_spykingcircus_extractor(self): path1 = self.test_dir + '/sc' se.SpykingCircusSortingExtractor.write_sorting(self.SX, path1) SX_spy = se.SpykingCircusSortingExtractor(path1) check_sorting_return_types(SX_spy) check_sortings_equal(self.SX, SX_spy) check_dumping(SX_spy)
def test_hs2_extractor(self): path1 = self.test_dir + '/firings_true.hdf5' se.HS2SortingExtractor.write_sorting(self.SX, path1) SX_hs2 = se.HS2SortingExtractor(path1) check_sorting_return_types(SX_hs2) check_sortings_equal(self.SX, SX_hs2) self.assertEqual(SX_hs2.get_sampling_frequency(), self.SX.get_sampling_frequency()) check_dumping(SX_hs2)
def test_cell_explorer_extractor(self): sorter_id = "cell_explorer_sorter" cell_explorer_dir = Path(self.test_dir) / sorter_id spikes_matfile_path = cell_explorer_dir / f"{sorter_id}.spikes.cellinfo.mat" se.CellExplorerSortingExtractor.write_sorting( sorting=self.SX, save_path=spikes_matfile_path) SX_cell_explorer = se.CellExplorerSortingExtractor( spikes_matfile_path=spikes_matfile_path) check_sorting_return_types(SX_cell_explorer) check_sortings_equal(self.SX, SX_cell_explorer) check_dumping(SX_cell_explorer)
def test_hdsort_extractor(self): path = self.test_dir + '/results_test_hdsort_extractor.mat' locations = np.ones((10, 2)) se.HDSortSortingExtractor.write_sorting(self.SX, path, locations=locations, noise_std_by_channel=None) SX_hd = se.HDSortSortingExtractor(path) check_sorting_return_types(SX_hd) check_sortings_equal(self.SX, SX_hd) check_dumping(SX_hd)
def test_npz_extractor(self): path = self.test_dir + '/sorting.npz' se.NpzSortingExtractor.write_sorting(self.SX, path) SX_npz = se.NpzSortingExtractor(path) # empty write sorting_empty = se.NumpySortingExtractor() path_empty = self.test_dir + '/sorting_empty.npz' se.NpzSortingExtractor.write_sorting(sorting_empty, path_empty) check_sorting_return_types(SX_npz) check_sortings_equal(self.SX, SX_npz) check_dumping(SX_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_convert_sorting_extractor_to_nwb(self, se_class, dataset_path, se_kwargs): print(f"\n\n\n TESTING {se_class.extractor_name}...") dataset_stem = Path(dataset_path).stem self.dataset.get(dataset_path) sorting = se_class(**se_kwargs) sf = sorting.get_sampling_frequency() if sf is None: # need to set dummy sampling frequency since no associated acquisition in file sf = 30000 sorting.set_sampling_frequency(sf) if test_nwb: nwb_save_path = self.savedir / f"{se_class.__name__}_test_{dataset_stem}.nwb" se.NwbSortingExtractor.write_sorting(sorting, nwb_save_path) nwb_sorting = se.NwbSortingExtractor(nwb_save_path, sampling_frequency=sf) check_sortings_equal(sorting, nwb_sorting) if test_caching: sort_cache = se.CacheSortingExtractor(sorting) check_sortings_equal(sorting, sort_cache)
def test_write_sorting(self): path = self.test_dir + '/test.nwb' sf = self.RX.get_sampling_frequency() # Append sorting to existing file write_recording(recording=self.RX, save_path=path, overwrite=True) write_sorting(sorting=self.SX, save_path=path, overwrite=False) SX_nwb = se.NwbSortingExtractor(path) 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.") write_sorting( sorting=self.SX, save_path=path, property_descriptions=property_descriptions, overwrite=True ) SX_nwb = se.NwbSortingExtractor(path, sampling_frequency=sf) check_sortings_equal(self.SX, SX_nwb) check_dumping(SX_nwb) # Test for handling skip_properties argument write_sorting( sorting=self.SX, save_path=path, skip_properties=['stability'], overwrite=True ) SX_nwb = se.NwbSortingExtractor(path, sampling_frequency=sf) 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 # SX2 has timestamps, so loading it back from Nwb will not recover the same spike frames. Set use_times=False write_sorting( sorting=self.SX2, save_path=path, skip_features=['widths'], use_times=False, overwrite=True ) SX_nwb = se.NwbSortingExtractor(path, sampling_frequency=sf) assert 'widths' not in SX_nwb.get_shared_unit_spike_feature_names() check_sortings_equal(self.SX2, SX_nwb) check_dumping(SX_nwb)
def test_multi_sub_sorting_extractor(self): N = self.RX.get_num_frames() SX_multi = se.MultiSortingExtractor( sortings=[self.SX, self.SX, self.SX], ) SX_multi.set_unit_property(unit_id=1, property_name='dummy', value=5) SX_sub = se.SubSortingExtractor(parent_sorting=SX_multi, start_frame=0) check_sortings_equal(SX_multi, SX_sub) self.assertEqual(SX_multi.get_unit_property(1, 'dummy'), SX_sub.get_unit_property(1, 'dummy')) N = self.RX.get_num_frames() SX_multi = se.MultiSortingExtractor(sortings=[self.SX, self.SX2], ) SX_sub1 = se.SubSortingExtractor(parent_sorting=SX_multi, start_frame=0, end_frame=N) check_sortings_equal(SX_multi, SX_sub1) check_sortings_equal(self.SX, SX_multi.sortings[0]) check_sortings_equal(self.SX2, SX_multi.sortings[1])
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