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_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_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_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)
