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 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, [], {})