def save_register_new_loader(self, filename):
"""
Save and register new loader file to specutils loader directory.
If a loader with the current name already exists it will be
deleted.
Parameters
----------
filename: str
Loader filename. If filename does not end in ".py", ".py" will be appended
to the end of the string.
"""
filename = "{}.py".format(filename) if not filename.endswith(".py") else filename
string = self.as_new_loader()
with open(filename, 'w') as f:
f.write(string)
# If a loader by this name exists, delete it
if self.new_loader_dict['name'] in registry.get_formats()['Format']:
registry.unregister_reader(self.new_loader_dict['name'], Spectrum1D)
registry.unregister_identifier(self.new_loader_dict['name'], Spectrum1D)
# Add new loader to registry
spec = importlib.util.spec_from_file_location(os.path.basename(filename)[:-3], filename)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
QMessageBox.information(self,
"Loader saved successful.",
"Custom loader was saved successfully.")
def test_custom_identifier(tmpdir):
good_fname = str(tmpdir.join('good.txt'))
bad_fname = str(tmpdir.join('bad.txt'))
# Create test data files.
for name in [good_fname, bad_fname]:
with open(name, 'w') as ff:
ff.write('\n')
format_name = 'custom_identifier_test'
def identifier(origin, *args, **kwargs):
fname = args[0]
return 'good' in fname
@data_loader(format_name, identifier=identifier)
def reader(*args, **kwargs):
"""Doesn't actually get used."""
return
for datatype in [Spectrum1D, SpectrumList]:
fmts = registry.identify_format('read', datatype, good_fname, None, [],
{})
assert format_name in fmts
fmts = registry.identify_format('read', datatype, bad_fname, None, [],
{})
assert format_name not in fmts
# Clean up after ourselves
registry.unregister_reader(format_name, datatype)
registry.unregister_identifier(format_name, datatype)
def save_register_new_loader(self, filename):
"""
Save and register new loader file to specutils loader directory.
If a loader with the current name already exists it will be
deleted.
Parameters
----------
filename: str
Loader filename. If filename does not end in ".py", ".py" will be appended
to the end of the string.
"""
filename = "{}.py".format(
filename) if not filename.endswith(".py") else filename
string = self.as_new_loader()
with open(filename, 'w') as f:
f.write(string)
# If a loader by this name exists, delete it
if self.new_loader_dict['name'] in registry.get_formats()['Format']:
registry.unregister_reader(self.new_loader_dict['name'],
Spectrum1D)
registry.unregister_identifier(self.new_loader_dict['name'],
Spectrum1D)
# Add new loader to registry
spec = importlib.util.spec_from_file_location(
os.path.basename(filename)[:-3], filename)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
QMessageBox.information(self, "Loader saved successful.",
"Custom loader was saved successfully.")
def test_default_identifier_extension(tmpdir):
good_fname = str(tmpdir.join('empty.fits'))
bad_fname = str(tmpdir.join('empty.txt'))
# Create test data files.
for name in [good_fname, bad_fname]:
with open(name, 'w') as ff:
ff.write('\n')
format_name = 'default_identifier_extension_test'
@data_loader(format_name, extensions=['fits'])
def reader(*args, **kwargs):
"""Doesn't actually get used."""
return
for datatype in [Spectrum1D, SpectrumList]:
fmts = registry.identify_format('read', datatype, good_fname, None, [],
{})
assert format_name in fmts
fmts = registry.identify_format('read', datatype, bad_fname, None, [],
{})
assert format_name not in fmts
# Clean up after ourselves
registry.unregister_reader(format_name, datatype)
registry.unregister_identifier(format_name, datatype)
def read_obslog(filename, fmt='auto'):
"""Read the observing log.
Args:
filename (str): Filename of the observing log file.
fmt (str): Format of the log file.
Returns:
:class:`astropy.table.Table`: An observing log object.
"""
# customized obslog format
if fmt == 'obslog':
registry.register_reader('obslog', Table, _read_obslog)
table = Table.read(filename, format='obslog')
registry.unregister_reader('obslog', Table)
# astropy format
elif fmt == 'astropy':
table = Table.read(filename, format='ascii.fixed_width_two_line')
# auto selection
elif fmt == 'auto':
try:
table = Table.read(filename, format='ascii.fixed_width_two_line')
except:
registry.register_reader('obslog', Table, _read_obslog)
table = Table.read(filename, format='obslog')
registry.unregister_reader('obslog', Table)
else:
table = None
return table
def save_register_new_loader(self, filename):
filename = "{}.py".format(
filename) if not filename.endswith(".py") else filename
string = self.as_new_loader()
with open(filename, 'w') as f:
f.write(string)
# If a loader by this name exists, delete it
if self.new_loader_dict['name'] in registry.get_formats()['Format']:
registry.unregister_reader(self.new_loader_dict['name'],
Spectrum1D)
registry.unregister_identifier(self.new_loader_dict['name'],
Spectrum1D)
# Add new loader to registry
spec = importlib.util.spec_from_file_location(
os.path.basename(filename)[:-3], filename)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
message_box = QMessageBox()
message_box.setText("Loader saved successful.")
message_box.setIcon(QMessageBox.Information)
message_box.setInformativeText("Custom loader was saved successfully.")
message_box.exec()
def test_default_identifier_extension(tmpdir):
good_fname = str(tmpdir.join('empty.fits'))
bad_fname = str(tmpdir.join('empty.txt'))
# Create test data files.
for name in [good_fname, bad_fname]:
with open(name, 'w') as ff:
ff.write('\n')
format_name = 'default_identifier_extension_test'
@data_loader(format_name, extensions=['fits'])
def reader(*args, **kwargs):
"""Doesn't actually get used."""
return
for datatype in [Spectrum1D, SpectrumList]:
fmts = registry.identify_format('read', datatype, good_fname, None, [], {})
assert format_name in fmts
fmts = registry.identify_format('read', datatype, bad_fname, None, [], {})
assert format_name not in fmts
# Clean up after ourselves
registry.unregister_reader(format_name, datatype)
registry.unregister_identifier(format_name, datatype)
def test_custom_identifier(tmpdir):
good_fname = str(tmpdir.join('good.txt'))
bad_fname = str(tmpdir.join('bad.txt'))
# Create test data files.
for name in [good_fname, bad_fname]:
with open(name, 'w') as ff:
ff.write('\n')
format_name = 'custom_identifier_test'
def identifier(origin, *args, **kwargs):
fname = args[0]
return 'good' in fname
@data_loader(format_name, identifier=identifier)
def reader(*args, **kwargs):
"""Doesn't actually get used."""
return
for datatype in [Spectrum1D, SpectrumList]:
fmts = registry.identify_format('read', datatype, good_fname, None, [], {})
assert format_name in fmts
fmts = registry.identify_format('read', datatype, bad_fname, None, [], {})
assert format_name not in fmts
# Clean up after ourselves
registry.unregister_reader(format_name, datatype)
registry.unregister_identifier(format_name, datatype)
def setup_readwrite(self):
"""Setup & teardown for read/write tests."""
# register
io_registry.register_reader("json", Cosmology, read_json)
io_registry.register_writer("json", Cosmology, write_json)
io_registry.register_identifier("json", Cosmology, json_identify)
yield # run all tests in class
# unregister
io_registry.unregister_reader("json", Cosmology)
io_registry.unregister_writer("json", Cosmology)
io_registry.unregister_identifier("json", Cosmology)
def test_register_reader():
io_registry.register_reader('test1', TestData, empty_reader)
io_registry.register_reader('test2', TestData, empty_reader)
assert io_registry.get_reader('test1', TestData) == empty_reader
assert io_registry.get_reader('test2', TestData) == empty_reader
io_registry.unregister_reader('test1', TestData)
with pytest.raises(io_registry.IORegistryError):
io_registry.get_reader('test1', TestData)
assert io_registry.get_reader('test2', TestData) == empty_reader
io_registry.unregister_reader('test2', TestData)
with pytest.raises(io_registry.IORegistryError):
io_registry.get_reader('test2', TestData)
def test_default_identifier(tmpdir):
fname = str(tmpdir.join('empty.txt'))
with open(fname, 'w') as ff:
ff.write('\n')
format_name = 'default_identifier_test'
@data_loader(format_name)
def reader(*args, **kwargs):
"""Doesn't actually get used."""
return
for datatype in [Spectrum1D, SpectrumList]:
fmts = registry.identify_format('read', datatype, fname, None, [], {})
assert format_name in fmts
# Clean up after ourselves
registry.unregister_reader(format_name, datatype)
registry.unregister_identifier(format_name, datatype)
def test_default_identifier(tmpdir):
fname = str(tmpdir.join('empty.txt'))
with open(fname, 'w') as ff:
ff.write('\n')
format_name = 'default_identifier_test'
@data_loader(format_name)
def reader(*args, **kwargs):
"""Doesn't actually get used."""
return
for datatype in [Spectrum1D, SpectrumList]:
fmts = registry.identify_format('read', datatype, fname, None, [], {})
assert format_name in fmts
# Clean up after ourselves
registry.unregister_reader(format_name, datatype)
registry.unregister_identifier(format_name, datatype)
def test_loader_uses_priority(tmpdir):
counter = Counter()
fname = str(tmpdir.join('good.txt'))
with open(fname, 'w') as ff:
ff.write('\n')
def identifier(origin, *args, **kwargs):
fname = args[0]
return 'good' in fname
@data_loader("test_counting_loader1", identifier=identifier, priority=1)
def counting_loader1(*args, **kwargs):
counter["test1"] += 1
wave = np.arange(1, 1.1, 0.01) * u.AA
return Spectrum1D(
spectral_axis=wave,
flux=np.ones(len(wave)) * 1.e-14 * u.Jy,
)
@data_loader("test_counting_loader2", identifier=identifier, priority=2)
def counting_loader2(*args, **kwargs):
counter["test2"] += 1
wave = np.arange(1, 1.1, 0.01) * u.AA
return Spectrum1D(
spectral_axis=wave,
flux=np.ones(len(wave)) * 1.e-14 * u.Jy,
)
Spectrum1D.read(fname)
assert counter["test2"] == 1
assert counter["test1"] == 0
for datatype in [Spectrum1D, SpectrumList]:
registry.unregister_reader("test_counting_loader1", datatype)
registry.unregister_identifier("test_counting_loader1", datatype)
registry.unregister_reader("test_counting_loader2", datatype)
registry.unregister_identifier("test_counting_loader2", datatype)
def test_unregister_reader_invalid():
with pytest.raises(io_registry.IORegistryError) as exc:
io_registry.unregister_reader('test', TestData)
assert str(exc.value) == "No reader defined for format 'test' and class 'TestData'"
def teardown_module(module):
"""clean up module after tests."""
io_registry.unregister_reader("json", Cosmology)
io_registry.unregister_writer("json", Cosmology)
io_registry.unregister_identifier("json", Cosmology)
def teardown_module(module):
"""clean up module after tests."""
with pytest.warns(FutureWarning): # idk
io_registry.unregister_reader("json", Cosmology)
io_registry.unregister_writer("json", Cosmology)
io_registry.unregister_identifier("json", Cosmology)
