def test_register_identifier():
io_registry.register_identifier('test1', TestData, empty_identifier)
io_registry.register_identifier('test2', TestData, empty_identifier)
io_registry.unregister_identifier('test1', TestData)
io_registry.unregister_identifier('test2', TestData)
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 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 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_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 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_register_identifier():
io_registry.register_identifier('test1', TestData, empty_identifier)
io_registry.register_identifier('test2', TestData, empty_identifier)
io_registry.unregister_identifier('test1', TestData)
io_registry.unregister_identifier('test2', TestData)
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 unregister(format):
"""
The unregistered format also stays the less preferred format even once its restored
"""
_low_priority_loaders[format] = True
if format not in _unregistered_loaders.keys():
_unregistered_loaders[format] = SpectrumList
_unregistered_identifiers[format] = registry._identifiers[(
format, SpectrumList)]
registry.unregister_identifier(format, SpectrumList)
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 teardown():
"""Clean up module after tests."""
yield # to let all tests within the scope run
if ASTROPY_GE_5:
from astropy.cosmology import Cosmology
from astropy.io import registry as io_registry
io_registry.unregister_reader("myformat", Cosmology)
io_registry.unregister_writer("myformat", Cosmology)
io_registry.unregister_identifier("myformat", Cosmology)
io_registry.unregister_reader("mypackage", Cosmology)
io_registry.unregister_writer("mypackage", Cosmology)
io_registry.unregister_identifier("mypackage", Cosmology)
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 unregister(format):
if format not in unregistered_loaders:
unregistered_loaders[format] = SpectrumList
registry.unregister_identifier(format, SpectrumList)
def test_unregister_identifier_invalid():
with pytest.raises(io_registry.IORegistryError) as exc:
io_registry.unregister_identifier('test', TestData)
assert str(exc.value) == "No identifier 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 test_unregister_identifier_invalid():
with pytest.raises(io_registry.IORegistryError) as exc:
io_registry.unregister_identifier('test', TestData)
assert str(
exc.value
) == "No identifier defined for format 'test' and class 'TestData'"
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)
