def test_write_clobber(self): io = HDF5IO(self.path, self.manager) io.write(self.container) io.close() f = File(self.path) # noqa: F841 if six.PY2: assert_file_exists = IOError elif six.PY3: assert_file_exists = OSError with self.assertRaises(assert_file_exists): io = HDF5IO(self.path, self.manager, mode='w-') io.write(self.container) io.close()
def main(): ep = """ use --nspath to validate against an extension. If --ns is not specified, validate against all namespaces in namespace file. """ parser = ArgumentParser(description="Validate an NWB file", epilog=ep) parser.add_argument("path", type=str, help="the path to the NWB file") parser.add_argument('-p', '--nspath', type=str, help="the path to the namespace file") parser.add_argument("-n", "--ns", type=str, help="the namespace to validate against") args = parser.parse_args() if not os.path.exists(args.path): print('%s not found' % args.path, file=sys.stderr) sys.exit(1) io = HDF5IO(args.path, get_manager(), mode='r') if args.nspath is not None: namespaces = load_namespaces(args.nspath) if args.ns is not None: print('Validating against %s from %s.' % (args.ns, args.ns_path)) else: print('Validating using namespaces in %s.' % args.nspath) for ns in namespaces: print('Validating against %s' % ns) errors = validate(io, ns) _print_errors(errors) else: errors = validate(io) print('Validating against core namespace') _print_errors(errors)
def testInFromMatNWB(self): filename = 'MatNWB.' + self.__class__.__name__ + '.testOutToPyNWB.nwb' with HDF5IO(filename, manager=get_manager(), mode='r') as io: matfile = io.read() matcontainer = self.getContainer(matfile) pycontainer = self.getContainer(self.file) self.assertContainerEqual(matcontainer, pycontainer)
def main(): import os.path # example: start from datetime import datetime from pynwb import NWBFile, TimeSeries, get_manager from pynwb.form.backends.hdf5 import HDF5IO start_time = datetime(1970, 1, 1, 12, 0, 0) create_date = datetime(2017, 4, 15, 12, 0, 0) nwbfile = NWBFile('the PyNWB tutorial', 'a test NWB File', 'TEST123', start_time, file_create_date=create_date) ts = TimeSeries('test_timeseries', 'example_source', list(range(100, 200, 10)), 'SIunit', timestamps=list(range(10)), resolution=0.1) nwbfile.add_acquisition(ts) io = HDF5IO("example.h5", manager=get_manager(), mode='w') io.write(nwbfile) io.close() # example: end os.remove("example.h5")
def test_read_builder(self): self.maxDiff = None io = HDF5IO(self.path, self.manager) io.write_builder(self.builder) builder = io.read_builder() self.assertBuilderEqual(builder, self.builder) io.close()
def test_write_attribute_reference_builder(self): writer = HDF5IO(self.path, self.manager) self.builder.set_attribute('ref_attribute', self.ts_builder) writer.write_builder(self.builder) writer.close() f = self.check_fields() self.assertIsInstance(f.attrs['ref_attribute'], Reference) self.assertEqual(f['acquisition/timeseries/test_timeseries'], f[f.attrs['ref_attribute']])
def test_overwrite_written(self): self.maxDiff = None io = HDF5IO(self.path, self.manager) io.write_builder(self.builder) builder = io.read_builder() with self.assertRaisesRegex(ValueError, "cannot change written to not written"): builder.written = False io.close()
def test_read(self): hdf5io = HDF5IO(self.path, self.manager) hdf5io.write(self.container) hdf5io.close() container = hdf5io.read() self.assertIsInstance(container, NWBFile) raw_ts = container.acquisition self.assertEqual(len(raw_ts), 1) self.assertIsInstance(raw_ts[0], TimeSeries) hdf5io.close()
def roundtripContainer(self): description = 'a file to test writing and reading a %s' % self.container_type identifier = 'TEST_%s' % self.container_type nwbfile = NWBFile(description, identifier, self.start_time, file_create_date=self.create_date) self.addContainer(nwbfile) self.writer = HDF5IO(self.filename, manager=get_manager(), mode='w') self.writer.write(nwbfile) self.writer.close() self.reader = HDF5IO(self.filename, manager=get_manager(), mode='r') read_nwbfile = self.reader.read() try: tmp = self.getContainer(read_nwbfile) return tmp except Exception as e: self.reader.close() self.reader = None raise e
def test_roundtrip(self): description = 'a file to test writing and reading a %s' % self.container_type source = 'test_roundtrip for %s' % self.container_type identifier = 'TEST_%s' % self.container_type nwbfile = NWBFile(source, description, identifier, self.start_time, file_create_date=self.create_date) self.addContainer(nwbfile) io = HDF5IO(self.filename, self.manager) io.write(nwbfile) try: read_nwbfile = io.read() read_container = self.getContainer(read_nwbfile) self.assertContainerEqual(self.container, read_container) finally: io.close()
def test_nwbio(self): io = HDF5IO(self.path, self.manager) io.write(self.container) io.close() f = File(self.path) self.assertIn('acquisition', f) self.assertIn('analysis', f) self.assertIn('general', f) self.assertIn('processing', f) self.assertIn('file_create_date', f) self.assertIn('identifier', f) self.assertIn('session_description', f) self.assertIn('session_start_time', f) acq = f.get('acquisition') self.assertIn('test_timeseries', acq)
def roundtripContainer(self): description = 'a file to test writing and reading a %s' % self.container_type source = 'test_roundtrip for %s' % self.container_type identifier = 'TEST_%s' % self.container_type nwbfile = NWBFile(source, description, identifier, self.start_time, file_create_date=self.create_date) self.addContainer(nwbfile) self.io = HDF5IO(self.filename, self.manager) self.io.write(nwbfile) read_nwbfile = self.io.read() try: tmp = self.getContainer(read_nwbfile) return tmp except Exception as e: self.io.close() self.io = None raise e
def test_write(self): hdf5io = HDF5IO(self.path, self.manager) hdf5io.write(self.container) hdf5io.close()
def readfile(filename): io = HDF5IO(filename, manager=pynwb.get_manager(), mode='r') nwbfile = io.read() io.close() return nwbfile
def test_write_context_manager(self): with HDF5IO(self.path, self.manager) as writer: writer.write_builder(self.builder) self.check_fields()
def test_write_builder(self): writer = HDF5IO(self.path, self.manager) writer.write_builder(self.builder) writer.close() self.check_fields()
def test_write(self): hdf5io = HDF5IO(self.path, manager=self.manager, mode='a') hdf5io.write(self.container) hdf5io.close()
def testOutToMatNWB(self): filename = 'PyNWB.' + self.__class__.__name__ + '.testOutToMatNWB.nwb' with HDF5IO(filename, manager=get_manager(), mode='w') as io: io.write(self.file) self.assertTrue(os.path.isfile(filename))
def testOutToMatNWB(self): filename = 'PyNWB.' + self.__class__.__name__ + '.testOutToMatNWB.nwb' io = HDF5IO(filename, manager=get_manager()) io.write(self.file) io.close() self.assertTrue(os.path.isfile(filename))
def main(): import os.path # prerequisites: start import numpy as np rate = 10.0 np.random.seed(1234) data_len = 1000 ephys_data = np.random.rand(data_len) ephys_timestamps = np.arange(data_len) / rate spatial_timestamps = ephys_timestamps[::10] spatial_data = np.cumsum(np.random.normal(size=(2, len(spatial_timestamps))), axis=-1).T # prerequisites: end # create-nwbfile: start from datetime import datetime from pynwb import NWBFile f = NWBFile('the PyNWB tutorial', 'my first synthetic recording', 'EXAMPLE_ID', datetime.now(), experimenter='Dr. Bilbo Baggins', lab='Bag End Laboratory', institution='University of Middle Earth at the Shire', experiment_description='I went on an adventure with thirteen dwarves to reclaim vast treasures.', session_id='LONELYMTN') # create-nwbfile: end # save-nwbfile: start from pynwb import get_manager from pynwb.form.backends.hdf5 import HDF5IO filename = "example.h5" io = HDF5IO(filename, manager=get_manager(), mode='w') io.write(f) io.close() # save-nwbfile: end os.remove(filename) # create-device: start device = f.create_device(name='trodes_rig123', source="a source") # create-device: end # create-electrode-groups: start electrode_name = 'tetrode1' source = "an hypothetical source" description = "an example tetrode" location = "somewhere in the hippocampus" electrode_group = f.create_electrode_group(electrode_name, source=source, description=description, location=location, device=device) # create-electrode-groups: end # create-electrode-table-region: start for idx in [1, 2, 3, 4]: f.add_electrode(idx, x=1.0, y=2.0, z=3.0, imp=float(-idx), location='CA1', filtering='none', description='channel %s' % idx, group=electrode_group) electrode_table_region = f.create_electrode_table_region([0, 2], 'the first and third electrodes') # create-electrode-table-region: end # create-timeseries: start from pynwb.ecephys import ElectricalSeries from pynwb.behavior import SpatialSeries ephys_ts = ElectricalSeries('test_ephys_data', 'an hypothetical source', ephys_data, electrode_table_region, timestamps=ephys_timestamps, # Alternatively, could specify starting_time and rate as follows # starting_time=ephys_timestamps[0], # rate=rate, resolution=0.001, comments="This data was randomly generated with numpy, using 1234 as the seed", description="Random numbers generated with numpy.random.rand") f.add_acquisition(ephys_ts) spatial_ts = SpatialSeries('test_spatial_timeseries', 'a stumbling rat', spatial_data, 'origin on x,y-plane', timestamps=spatial_timestamps, resolution=0.1, comments="This data was generated with numpy, using 1234 as the seed", description="This 2D Brownian process generated with " "np.cumsum(np.random.normal(size=(2, len(spatial_timestamps))), axis=-1).T") f.add_acquisition(spatial_ts) # create-timeseries: end # create-data-interface: start from pynwb.ecephys import LFP from pynwb.behavior import Position lfp = f.add_acquisition(LFP('a hypothetical source')) ephys_ts = lfp.create_electrical_series('test_ephys_data', 'an hypothetical source', ephys_data, electrode_table_region, timestamps=ephys_timestamps, resolution=0.001, comments="This data was randomly generated with numpy, using 1234 as the seed", # noqa: E501 description="Random numbers generated with numpy.random.rand") pos = f.add_acquisition(Position('a hypothetical source')) spatial_ts = pos.create_spatial_series('test_spatial_timeseries', 'a stumbling rat', spatial_data, 'origin on x,y-plane', timestamps=spatial_timestamps, resolution=0.1, comments="This data was generated with numpy, using 1234 as the seed", description="This 2D Brownian process generated with " "np.cumsum(np.random.normal(size=(2, len(spatial_timestamps))), axis=-1).T") # noqa: E501 # create-data-interface: end # create-epochs: start epoch_tags = ('example_epoch',) f.create_epoch(name='epoch1', start_time=0.0, stop_time=1.0, tags=epoch_tags, description="the first test epoch", timeseries=[ephys_ts, spatial_ts]) f.create_epoch(name='epoch2', start_time=0.0, stop_time=1.0, tags=epoch_tags, description="the second test epoch", timeseries=[ephys_ts, spatial_ts]) # create-epochs: end # create-compressed-timeseries: start from pynwb.ecephys import ElectricalSeries from pynwb.behavior import SpatialSeries from pynwb.form.backends.hdf5 import H5DataIO ephys_ts = ElectricalSeries('test_compressed_ephys_data', 'an hypothetical source', H5DataIO(ephys_data, compress=True), electrode_table_region, timestamps=H5DataIO(ephys_timestamps, compress=True), resolution=0.001, comments="This data was randomly generated with numpy, using 1234 as the seed", description="Random numbers generated with numpy.random.rand") f.add_acquisition(ephys_ts) spatial_ts = SpatialSeries('test_compressed_spatial_timeseries', 'a stumbling rat', H5DataIO(spatial_data, compress=True), 'origin on x,y-plane', timestamps=H5DataIO(spatial_timestamps, compress=True), resolution=0.1, comments="This data was generated with numpy, using 1234 as the seed", description="This 2D Brownian process generated with " "np.cumsum(np.random.normal(size=(2, len(spatial_timestamps))), axis=-1).T") f.add_acquisition(spatial_ts)
def writefile(nwbfile, filename): io = HDF5IO(filename, manager=pynwb.get_manager(), mode='w') io.write(nwbfile) io.close()