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)
