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
