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 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 whatformat_get_valid_format(mode, cls, path, fileobj, args, kwargs):
"""
Returns the first valid format that can be used to read/write the data in
question. Mode can be either 'read' or 'write'.
"""
valid_formats = registry.identify_format(mode, cls, path, fileobj, args,
kwargs)
# A low priority loader is only intended to be used if its the only one
reordered = []
for format in valid_formats:
if format in _low_priority_loaders:
reordered.append(format)
for format in valid_formats:
if not format in _low_priority_loaders:
reordered.append(format)
return reordered
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 identify_spectrum_format(filename, dtype=Spectrum1D):
""" Attempt to identify a spectrum file format
Given a filename, attempts to identify a valid file format
from the list of registered specutils loaders. Essentially a wrapper for
`~astropy.io.registry.identify_format` setting **origin** to ``read`` and
**data_class_required** to `~specutils.Spectrum1D`.
Parameters
----------
filename : str
A path to a file to be identified
dtype: object
class type of Spectrum1D, SpectrumList, or SpectrumCollection. Default is
Spectrum1D.
Returns
-------
valid_format : list, str
A list of valid file formats. If only one valid format found, returns
just that element.
"""
# check for valid string input
if not isinstance(filename,
(str, pathlib.Path)) or not os.path.isfile(filename):
raise ValueError(f'{filename} is not a valid string path to a file')
# check for proper class type
assert dtype in \
[Spectrum1D, SpectrumList, SpectrumCollection], \
'dtype class must be either Spectrum1D, SpectrumList, or SpectrumCollection'
# identify the file format
valid_format = io_registry.identify_format('read', dtype, filename, None,
{}, {})
if valid_format and len(valid_format) == 1:
return valid_format[0]
return valid_format
def whatformat_get_valid_format(mode, cls, path, fileobj, args, kwargs):
"""
Returns the first valid format that can be used to read/write the data in
question. Mode can be either 'read' or 'write'.
"""
valid_formats = registry.identify_format(mode, cls, path, fileobj, args, kwargs)
#if len(valid_formats) == 0:
# format_table_str = _get_format_table_str(cls, mode.capitalize())
# raise IORegistryError("Format could not be identified based on the"
# " file name or contents, please provide a"
# " 'format' argument.\n"
# "The available formats are:\n"
# "{}".format(format_table_str))
#elif len(valid_formats) > 1:
#registry.unregister_identifier(valid_formats[0],cls)
#raise IORegistryError(
# "Format is ambiguous - options are: {}".format(
# ', '.join(sorted(valid_formats, key=itemgetter(0)))))
return valid_formats
def format_from_hdulist(hdulist, *args, **kwargs):
info = hdulist.fileinfo(0)
formats = registry.identify_format('read', SpectrumList, None, None,
[hdulist], kwargs)
return formats[-1] if formats else None # We only want one format
def _get_matching_formats(self, file_path):
return io_registry.identify_format(
'read', SpectrumList, file_path, None, [], {})
def _get_matching_formats(self, file_path):
return io_registry.identify_format('read', SpectrumList, file_path,
None, [], {})
