def test_extract(tmpdir):
hdulist = HDUList()
image = ImageHDU(np.random.random((25, 25)))
hdulist.append(image)
tree = {
'some_words': 'These are some words',
'nested': {
'a': 100,
'b': 42
},
'list': [x for x in range(10)],
'image': image.data
}
asdf_in_fits = str(tmpdir.join('asdf.fits'))
with AsdfInFits(hdulist, tree) as aif:
aif.write_to(asdf_in_fits)
pure_asdf = str(tmpdir.join('extract.asdf'))
extract.extract_file(asdf_in_fits, pure_asdf)
assert os.path.exists(pure_asdf)
with asdf.open(pure_asdf) as af:
assert not isinstance(af, AsdfInFits)
assert_tree_match(tree, af.tree)
def createFromScratch(self, phu, extensions=None):
"""
Creates an AstroData object from a collection of objects.
"""
lst = HDUList()
if phu is not None:
if isinstance(phu, PrimaryHDU):
lst.append(phu)
elif isinstance(phu, Header):
lst.append(PrimaryHDU(header=deepcopy(phu), data=DELAYED))
elif isinstance(phu, (dict, list, tuple)):
p = PrimaryHDU()
p.header.update(phu)
lst.append(p)
else:
raise ValueError(
"phu must be a PrimaryHDU or a valid header object")
# TODO: Verify the contents of extensions...
if extensions is not None:
for ext in extensions:
lst.append(ext)
return self.getAstroData(lst)
def tofits(filename, data, hdr=None, clobber=False):
"""simple pyfits wrapper to make saving fits files easier."""
hdu = PrimaryHDU(data)
if not (hdr is None):
hdu.header += hdr
hdulist = HDUList([hdu])
hdulist.writeto(filename, overwrite=clobber, output_verify='ignore')
def to_hdu_list(self):
"""Convert to `~astropy.io.fits.HDUList`.
"""
hdu_list = HDUList()
for image in self:
hdu = image.to_image_hdu()
hdu_list.append(hdu)
return hdu_list
def test_datasets(self):
records = DALResults.from_result_url(
'http://example.com/query/dataset')
record = records[0]
assert record.getdataurl() == 'http://example.com/querydata/image.fits'
dataset = record.getdataset()
HDUList.fromstring(dataset.read())
def test_datasets(self):
records = DALResults.from_result_url(
'http://example.com/query/dataset')
record = records[0]
assert record.getdataurl() == 'http://example.com/querydata/image.fits'
dataset = record.getdataset()
HDUList.fromstring(dataset.read())
def to_hdu_list(self):
"""Convert to `~astropy.io.fits.HDUList`.
"""
hdu_list = HDUList()
for image in self:
hdu = image.to_image_hdu()
hdu_list.append(hdu)
return hdu_list
def export_visibility_to_fits(vis: Visibility, fits_file: str):
hdu = HDUList([
PrimaryHDU(),
configuration_to_hdu(vis.configuration),
visibility_to_hdu(vis)
])
with open(fits_file, "w") as f:
hdu.writeto(f, checksum=True)
def setup_class(self):
self.data1 = np.array(list(
zip([1, 2, 3, 4], ['a', 'b', 'c', 'd'], [2.3, 4.5, 6.7, 8.9])),
dtype=[('a', int), ('b', 'U1'), ('c', float)])
self.data2 = np.array(list(
zip([1.4, 2.3, 3.2, 4.7], [2.3, 4.5, 6.7, 8.9])),
dtype=[('p', float), ('q', float)])
hdu1 = PrimaryHDU()
hdu2 = BinTableHDU(self.data1, name='first')
hdu3 = BinTableHDU(self.data2, name='second')
self.hdus = HDUList([hdu1, hdu2, hdu3])
def save_fits(self, folder: str) -> str:
data = self.data.copy()
assert data.dtype == np.float32 and data.max() <= 1.0 and data.min() >= 0.0, f"{data.dtype} {data.max()} {data.min()}"
hdu = PrimaryHDU(
data=self.data,
header=self.fits_header,
)
l = HDUList([hdu])
path = join(folder, f"{self.key}.fits")
l.writeto(path, overwrite=True)
return path
def trim_throughput(indir, outdir):
'''downsample throughput files'''
assert os.path.basename(indir) == 'throughput'
if not os.path.exists(outdir):
os.makedirs(outdir)
for targettype in ('elg', 'lrg', 'perfect', 'qso', 'sky', 'star'):
filename = 'fiberloss-{}.dat'.format(targettype)
shutil.copy(os.path.join(indir, filename),
os.path.join(outdir, filename))
for filename in ['thru-b.fits', 'thru-r.fits', 'thru-z.fits']:
fx = fits.open(indir + '/' + filename)
hdus = HDUList()
hdus.append(fx[0])
hdus.append(BinTableHDU(fx[1].data[::20], header=fx[1].header))
hdus.append(BinTableHDU(fx[2].data[::20], header=fx[2].header))
hdus.writeto(outdir + '/' + filename)
fx.close()
for filename in [
'DESI-0347_blur.ecsv', 'DESI-0347_offset.ecsv',
'DESI-0347_random_offset_1.fits'
]:
shutil.copy(os.path.join(indir, filename),
os.path.join(outdir, filename))
async def write_fits(self, filename: str, hdulist: fits.HDUList,
*args: Any, **kwargs: Any) -> None:
"""Convenience function for writing an Image to a FITS file.
Args:
filename: Name of file to write.
hdulist: hdu list to write.
"""
# open file
async with self.open_file(filename, "wb") as f:
with io.BytesIO() as bio:
hdulist.writeto(bio, *args, **kwargs)
await f.write(bio.getvalue())
def from_hdu(hdu):
'''
Return a OneDSpectrum from a FITS HDU or HDU list.
'''
if isinstance(hdu, HDUList):
hdul = hdu
hdu = hdul[0]
else:
hdul = HDUList([hdu])
if not len(hdu.data.shape) == 1:
raise ValueError("HDU must contain one-dimensional data.")
meta = {}
mywcs = wcs.WCS(hdu.header)
if "BUNIT" in hdu.header:
unit = convert_bunit(hdu.header["BUNIT"])
meta["BUNIT"] = hdu.header["BUNIT"]
else:
unit = None
beams = cube_utils.try_load_beams(hdul)
self = OneDSpectrum(hdu.data,
unit=unit,
wcs=mywcs,
meta=meta,
header=hdu.header,
beams=beams)
return self
def setup_method(self, method):
from astropy.table import Table
from astropy.io.fits import HDUList, ImageHDU
Registry().clear()
x = [1, 2, 3]
y = [2, 3, 4]
u = [10, 20, 30, 40]
v = [20, 40, 60, 80]
self.xy = {'x': x, 'y': y}
self.dict_data = {'u': u, 'v': v}
self.recarray_data = np.rec.array([(0, 1), (2, 3)],
dtype=[(str('a'), int),
(str('b'), int)])
self.astropy_table = Table({'x': x, 'y': y})
self.bad_data = {'x': x, 'u': u}
self.hdulist = HDUList([ImageHDU(x, name='PRIMARY')])
self.x = np.array(x)
self.y = np.array(y)
self.u = np.array(u)
self.v = np.array(v)
def testFits(self):
"""Test I/O with FITS"""
from astropy.io.fits import HDUList
fits = HDUList()
self.fluxTable.toFits(fits)
ft = FluxTable.fromFits(fits)
self.assertFluxTable(ft)
def align(hduls, name="SCI", reference=None):
"""
Aligns the source astronomical image(s) to the reference astronomical image
\b
:param hduls: list of fitsfiles
:return: list of fistfiles with <name> HDU aligned
"""
hduls_list = [hdul for hdul in hduls]
sources = [hdul[name] for hdul in hduls_list]
outputs = []
if reference is None:
reference = snr.snr(hduls_list, name)[name]
# click.echo(reference.header["ORIGNAME"])
# FIXME log ref name
np_ref = to_np(
reference,
"Cannot align to unexpected type {}; expected numpy array or FITS HDU")
for source in sources:
np_src = to_np(
source,
"Cannot align unexpected type {}; expected numpy array or FITS HDU"
)
# possibly unneccessary but unsure about scoping
output = np.array([])
output = astroalign.register(np_src, np_ref)[0]
if isinstance(source, HDU_TYPES):
output = PrimaryHDU(output, source.header)
outputs.append(HDUList([output]))
return (hdul for hdul in outputs)
def hdulist(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
hdu = self.hdu
beamhdu = beams_to_bintable(self.beams)
return HDUList([hdu, beamhdu])
def fake_hdulist(extver=1, version=2, timesys="TDB", telescop="KEPLER"):
new_header = fake_header(extver, version, timesys, telescop)
return [
HDUList(hdus=[
PrimaryHDU(header=new_header),
BinTableHDU(header=new_header, name="LIGHTCURVE")
])
]
def random_position(image: fits.HDUList,
hg_ra: float,
hg_dec: float,
limit: int = 10,
show: bool = False):
image, path = ff.path_or_hdu(image)
header = image[0].header
data = image[0].data
# Find host galaxy pixel
wcs_info = wcs.WCS(header)
hg_x, hg_y = wcs_info.all_world2pix(hg_ra, hg_dec, 0)
hg_x = int(np.round(hg_x))
hg_y = int(np.round(hg_y))
image_copy = data.copy()[hg_y - limit:hg_y + limit,
hg_x - limit:hg_x + limit]
noise = np.median(image_copy)
image_copy = image_copy - noise
image_flatten = image_copy.flatten(1)
i = st.value_from_pdf(np.arange(image_flatten.shape[0]),
image_flatten / max(image_flatten))
i = int(i)
x, y = np.unravel_index(i, image_copy.shape)
if show:
plt.imshow(image_copy)
plt.scatter(x, y)
plt.show()
plt.close()
plt.plot(image_flatten / max(image_flatten))
plt.show()
x += hg_x - limit + np.random.uniform(-0.5, 0.5)
y += hg_y - limit + np.random.uniform(-0.5, 0.5)
ra, dec = wcs_info.all_pix2world(x, y, 0)
if path:
image.close()
return x, y, ra, dec
def trim_quickpsf(indir, outdir, filename):
assert os.path.abspath(indir) != os.path.abspath(outdir)
infile = os.path.join(indir, filename)
outfile = os.path.join(outdir, filename)
fx = fits.open(infile)
hdus = HDUList()
hdus.append(fx[0])
for i in [1,2,3]:
d = fx[i].data
hdus.append(BinTableHDU(d[::10], header=fx[i].header))
hdus.writeto(outfile, clobber=True)
fx.close()
def from_hdu(hdu):
'''
Return a OneDSpectrum from a FITS HDU or HDU list.
'''
if isinstance(hdu, HDUList):
hdul = hdu
hdu = hdul[0]
else:
hdul = HDUList([hdu])
if not len(hdu.data.shape) == 1:
raise ValueError("HDU must contain one-dimensional data.")
meta = {}
mywcs = wcs.WCS(hdu.header)
if "BUNIT" in hdu.header:
unit = convert_bunit(hdu.header["BUNIT"])
meta["BUNIT"] = hdu.header["BUNIT"]
else:
unit = None
beams_table = cube_utils.try_load_beams(hdul)
if beams_table is not None:
# Convert to a beams object from the table
beams = Beams(
major=u.Quantity(beams_table['BMAJ'], u.arcsec),
minor=u.Quantity(beams_table['BMIN'], u.arcsec),
pa=u.Quantity(beams_table['BPA'], u.deg),
meta=[{
key: row[key]
for key in beams_table.names
if key not in ('BMAJ', 'BPA', 'BMIN')
} for row in beams_table],
)
self = VaryingResolutionOneDSpectrum(hdu.data,
unit=unit,
wcs=mywcs,
meta=meta,
header=hdu.header,
beams=beams)
else:
beam = cube_utils.try_load_beam(hdu.header)
self = OneDSpectrum(hdu.data,
unit=unit,
wcs=mywcs,
meta=meta,
header=hdu.header,
beam=beam)
return self
def setup_class(self):
self.data1 = np.array(list(
zip([1, 2, 3, 4], ['a', 'b', 'c', 'd'], [2.3, 4.5, 6.7, 8.9])),
dtype=[('a', int), ('b', 'U1'), ('c', float)])
self.data2 = np.array(list(
zip([1.4, 2.3, 3.2, 4.7], [2.3, 4.5, 6.7, 8.9])),
dtype=[('p', float), ('q', float)])
self.data3 = np.array(list(zip([1, 2, 3, 4], [2.3, 4.5, 6.7, 8.9])),
dtype=[('A', int), ('B', float)])
hdu0 = PrimaryHDU()
hdu1 = BinTableHDU(self.data1, name='first')
hdu2 = BinTableHDU(self.data2, name='second')
hdu3 = ImageHDU(np.ones((3, 3)), name='third')
hdu4 = BinTableHDU(self.data3)
self.hdus = HDUList([hdu0, hdu1, hdu2, hdu3, hdu4])
self.hdusb = HDUList([hdu0, hdu3, hdu2, hdu1])
self.hdus3 = HDUList([hdu0, hdu3, hdu2])
self.hdus2 = HDUList([hdu0, hdu1, hdu3])
self.hdus1 = HDUList([hdu0, hdu1])
def _create_fits(self):
hdul = HDUList(PrimaryHDU())
h = hdul[0].header
h.append(Card('name', self.name))
self._cf_pre_hook(hdul)
self._cf_add_setup_info(hdul)
self._cf_post_setup_hook(hdul)
self._cf_add_summary_statistics(hdul)
self._cf_add_pipeline_steps(hdul)
self._cf_post_hook(hdul)
return hdul
def test_fitsdiff_openfile(tmpdir):
"""Make sure that failing FITSDiff doesn't leave open files."""
path1 = str(tmpdir.join("file1.fits"))
path2 = str(tmpdir.join("file2.fits"))
hdulist = HDUList([PrimaryHDU(), ImageHDU(data=np.zeros(5))])
hdulist.writeto(path1)
hdulist[1].data[0] = 1
hdulist.writeto(path2)
diff = FITSDiff(path1, path2)
assert diff.identical, diff.report()
def get_primary_extension(hdu: fits.HDUList):
"""
Figure out which is the primary extension (1 if fpacked, 0 otherwise)
:param hdu: astropy.io.fits.HDUList
:return: int
"""
_, file_extension = os.path.splitext(hdu.filename())
if file_extension == '.fz':
primary_extension = 1
else:
primary_extension = 0
return primary_extension
def setup_class(self):
self.data1 = np.array(list(zip([1, 2, 3, 4],
['a', 'b', 'c', 'd'],
[2.3, 4.5, 6.7, 8.9])),
dtype=[(str('a'), int), (str('b'), str('U1')), (str('c'), float)])
self.data2 = np.array(list(zip([1.4, 2.3, 3.2, 4.7],
[2.3, 4.5, 6.7, 8.9])),
dtype=[(str('p'), float), (str('q'), float)])
hdu1 = PrimaryHDU()
hdu2 = BinTableHDU(self.data1, name='first')
hdu3 = BinTableHDU(self.data2, name='second')
self.hdus = HDUList([hdu1, hdu2, hdu3])
def _prepare_hdulist(hdulist, default_extension='SCI', extname_parser=None):
new_list = []
highest_ver = 0
recognized = set()
if len(hdulist) > 1 or (len(hdulist) == 1 and hdulist[0].data is None):
# MEF file
# First get HDUs for which EXTVER is defined
for n, hdu in enumerate(hdulist):
if extname_parser:
extname_parser(hdu)
ver = hdu.header.get('EXTVER')
if ver not in (-1, None) and hdu.name:
highest_ver = max(highest_ver, ver)
elif not isinstance(hdu, PrimaryHDU):
continue
new_list.append(hdu)
recognized.add(hdu)
# Then HDUs that miss EXTVER
for hdu in hdulist:
if hdu in recognized:
continue
elif isinstance(hdu, ImageHDU):
highest_ver += 1
if 'EXTNAME' not in hdu.header:
hdu.header['EXTNAME'] = (default_extension,
'Added by AstroData')
if hdu.header.get('EXTVER') in (-1, None):
hdu.header['EXTVER'] = (highest_ver, 'Added by AstroData')
new_list.append(hdu)
recognized.add(hdu)
else:
# Uh-oh, a single image FITS file
new_list.append(PrimaryHDU(header=hdulist[0].header))
image = ImageHDU(header=hdulist[0].header, data=hdulist[0].data)
# Fudge due to apparent issues with assigning ImageHDU from data
image._orig_bscale = hdulist[0]._orig_bscale
image._orig_bzero = hdulist[0]._orig_bzero
for keyw in ('SIMPLE', 'EXTEND'):
if keyw in image.header:
del image.header[keyw]
image.header['EXTNAME'] = (default_extension, 'Added by AstroData')
image.header['EXTVER'] = (1, 'Added by AstroData')
new_list.append(image)
return HDUList(sorted(new_list, key=fits_ext_comp_key))
def get_stamps(self, oid, candid=None):
"""Download Stamps for an specific alert.
Parameters
----------
oid : :py:class:`str`
object ID in ALeRCE DBs.
candid : :py:class:`int`
Candid of the stamp to be displayed.
Returns
-------
:class:`astropy.io.fits.HDUList`
Science, Template and Difference stamps for an specific alert.
"""
if candid is None:
candid = self._get_first_detection(oid)
try:
hdulist = HDUList()
for stamp_type in ["science", "template", "difference"]:
tmp_hdulist = fits_open(
"%s?oid=%s&candid=%s&type=%s&format=fits"
% (
self.config["AVRO_URL"]
+ self.config["AVRO_ROUTES"]["get_stamp"],
oid,
candid,
stamp_type,
)
)
hdu = tmp_hdulist[0]
hdu.header["STAMP_TYPE"] = stamp_type
hdulist.append(hdu)
return hdulist
except HTTPError:
warnings.warn("AVRO File not found.", RuntimeWarning)
return None
def from_hdu(hdu):
'''
Return a OneDSpectrum from a FITS HDU or HDU list.
'''
if isinstance(hdu, HDUList):
hdul = hdu
hdu = hdul[0]
else:
hdul = HDUList([hdu])
if not len(hdu.data.shape) == 1:
raise ValueError("HDU must contain one-dimensional data.")
meta = {}
mywcs = wcs.WCS(hdu.header)
if "BUNIT" in hdu.header:
unit = convert_bunit(hdu.header["BUNIT"])
meta["BUNIT"] = hdu.header["BUNIT"]
else:
unit = None
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=FITSWarning)
beam = cube_utils.try_load_beams(hdul)
if hasattr(beam, '__len__'):
beams = beam
else:
beams = None
if beams is not None:
self = VaryingResolutionOneDSpectrum(hdu.data,
unit=unit,
wcs=mywcs,
meta=meta,
header=hdu.header,
beams=beams)
else:
beam = cube_utils.try_load_beam(hdu.header)
self = OneDSpectrum(hdu.data,
unit=unit,
wcs=mywcs,
meta=meta,
header=hdu.header,
beam=beam)
return self
def writeFits(self, filename):
"""Write to FITS file
This API is intended for use by the LSST data butler, which handles
translating the desired identity into a filename.
Parameters
----------
filename : `str`
Filename of FITS file.
"""
from astropy.io.fits import HDUList, PrimaryHDU
fits = HDUList()
fits.append(PrimaryHDU())
self._writeImpl(fits)
with open(filename, "wb") as fd:
fits.writeto(fd)
def raw_converter_to_calibrated_hdulist(converter):
# type: (SingleCCDRawConverter) -> HDUList
"""
TODO: Document me
:param converter:
"""
early_dark_pixel_columns = converter.parameters.early_dark_pixel_columns # type: int
late_dark_pixel_columns = converter.parameters.late_dark_pixel_columns # type: int
# noinspection PyUnresolvedReferences
left_dark_parts = [
raw_slice.pixels[:, :early_dark_pixel_columns]
for raw_slice in converter.slices
] # type: list
# noinspection PyUnresolvedReferences
right_dark_parts = [
raw_slice.pixels[:, -late_dark_pixel_columns:]
for raw_slice in converter.slices
] # type: list
# noinspection PyUnresolvedReferences
image_parts = [
raw_slice.pixels[:, early_dark_pixel_columns:-late_dark_pixel_columns]
for raw_slice in converter.slices
] # type: list
for i in range(1, len(converter.slices), 2):
left_dark_parts[i] = numpy.fliplr(left_dark_parts[i])
right_dark_parts[i] = numpy.fliplr(right_dark_parts[i])
image_parts[i] = numpy.fliplr(image_parts[i])
header_with_parameters = set_header_settings(
converter.parameters, raw_converter_parameters,
converter.conversion_metadata.header)
header_with_transformation_flags = set_header_settings(
converter.flags, raw_transformation_flags, header_with_parameters)
if converter.conversion_metadata.command is not None:
header_with_transformation_flags.add_history(
converter.conversion_metadata.command)
return HDUList(
PrimaryHDU(
header=header_with_transformation_flags,
# `+` concatenates python lists
data=numpy.hstack(left_dark_parts + image_parts +
right_dark_parts)))
def hdu_to_imagemodel(in_hdu):
"""
Workaround for initializing a `jwst.datamodels.ImageModel` from a
normal FITS ImageHDU that could contain HST header keywords and
unexpected WCS definition.
TBD
Parameters
----------
in_hdu : `astropy.io.fits.ImageHDU`
Returns
-------
img : `jwst.datamodels.ImageModel`
"""
from astropy.io.fits import ImageHDU, HDUList
from astropy.coordinates import ICRS
from jwst.datamodels import util
import gwcs
hdu = ImageHDU(data=in_hdu.data, header=in_hdu.header)
new_header = strip_telescope_header(hdu.header)
hdu.header = new_header
# Initialize data model
img = util.open(HDUList([hdu]))
# Initialize GWCS
tform = gwcs.wcs.utils.make_fitswcs_transform(new_header)
hwcs = gwcs.WCS(forward_transform=tform,
output_frame=ICRS()) #gwcs.CelestialFrame())
sh = hdu.data.shape
hwcs.bounding_box = ((-0.5, sh[0] - 0.5), (-0.5, sh[1] - 0.5))
# Put gWCS in meta, where blot/drizzle expect to find it
img.meta.wcs = hwcs
return img
def write_fits(self, filename, overwrite=False):
r'''Write pipeline results to a FITS file.
Parameters
----------
filename : str
Name of output file to be written.
overwrite : bool
If filename already exists, this flag indicates whether or not to
overwrite it (without warning).
'''
from astropy.io.fits import HDUList, PrimaryHDU, table_to_hdu
hdul = [PrimaryHDU()]
for t in self.table_config:
hdu = table_to_hdu(self[t])
hdu.header['EXTNAME'] = t
hdul.append(hdu)
HDUList(hdul).writeto(filename, overwrite=overwrite)
def createFromScratch(self, phu, extensions=None):
"""
Creates an AstroData object from a collection of objects.
"""
lst = HDUList()
if phu is not None:
if isinstance(phu, PrimaryHDU):
lst.append(phu)
elif isinstance(phu, Header):
lst.append(PrimaryHDU(header=deepcopy(phu), data=DELAYED))
elif isinstance(phu, (dict, list, tuple)):
p = PrimaryHDU()
p.header.update(phu)
lst.append(p)
else:
raise ValueError("phu must be a PrimaryHDU or a valid header object")
# TODO: Verify the contents of extensions...
if extensions is not None:
for ext in extensions:
lst.append(ext)
return self.getAstroData(lst)
def mime_object_maker(url, mimetype):
"""
return a data object suitable for the mimetype given.
this will either return a astropy fits object or a pyvo DALResults object,
a PIL object for conventional images or string for text content.
Parameters
----------
url : str
the object download url
mimetype : str
the content mimetype
"""
mimetype = mimeparse.parse_mime_type(mimetype)
if mimetype[0] == 'text':
return s.get(url).text
if mimetype[1] == 'fits' or mimetype[1] == 'x-fits':
r = s.get(url)
return HDUList.fromstring(r.content)
if mimetype[0] == 'image':
from PIL import Image
from io import BytesIO
r = s.get(url)
b = BytesIO(r.content)
return Image.open(b)
if mimetype[1] == 'x-votable' or mimetype[1] == 'x-votable+xml':
# As soon as there are some kind of recursive data structures,
# things start to get really f*cked up
if mimetype[2].get('content', None) == 'datalink':
from .adhoc import DatalinkResults
return DatalinkResults.from_result_url(url)
else:
from .query import DALResults
return DALResults.from_result_url(url)
def test_ignore_hdus_report(self, capsys):
a = np.arange(100).reshape(10, 10)
b = a.copy() + 1
ha = Header([('A', 1), ('B', 2), ('C', 3)])
phdu_a = PrimaryHDU(header=ha)
phdu_b = PrimaryHDU(header=ha)
ihdu_a = ImageHDU(data=a, name='SCI')
ihdu_b = ImageHDU(data=b, name='SCI')
hdulist_a = HDUList([phdu_a, ihdu_a])
hdulist_b = HDUList([phdu_b, ihdu_b])
tmp_a = self.temp('testa.fits')
tmp_b = self.temp('testb.fits')
hdulist_a.writeto(tmp_a)
hdulist_b.writeto(tmp_b)
numdiff = fitsdiff.main([tmp_a, tmp_b, "-u", "SCI"])
assert numdiff == 0
out, err = capsys.readouterr()
assert "testa.fits" in out
assert "testb.fits" in out
class TestMultipleHDU:
def setup_class(self):
self.data1 = np.array(list(zip([1, 2, 3, 4],
['a', 'b', 'c', 'd'],
[2.3, 4.5, 6.7, 8.9])),
dtype=[(str('a'), int), (str('b'), str('U1')), (str('c'), float)])
self.data2 = np.array(list(zip([1.4, 2.3, 3.2, 4.7],
[2.3, 4.5, 6.7, 8.9])),
dtype=[(str('p'), float), (str('q'), float)])
hdu1 = PrimaryHDU()
hdu2 = BinTableHDU(self.data1, name='first')
hdu3 = BinTableHDU(self.data2, name='second')
self.hdus = HDUList([hdu1, hdu2, hdu3])
def teardown_class(self):
del self.hdus
def setup_method(self, method):
warnings.filterwarnings('always')
def test_read(self, tmpdir):
filename = str(tmpdir.join('test_read.fits'))
self.hdus.writeto(filename)
with catch_warnings() as l:
t = Table.read(filename)
assert len(l) == 1
assert str(l[0].message).startswith(
'hdu= was not specified but multiple tables are present, reading in first available table (hdu=1)')
assert equal_data(t, self.data1)
def test_read_with_hdu_0(self, tmpdir):
filename = str(tmpdir.join('test_read_with_hdu_0.fits'))
self.hdus.writeto(filename)
with pytest.raises(ValueError) as exc:
Table.read(filename, hdu=0)
assert exc.value.args[0] == 'No table found in hdu=0'
@pytest.mark.parametrize('hdu', [1, 'first'])
def test_read_with_hdu_1(self, tmpdir, hdu):
filename = str(tmpdir.join('test_read_with_hdu_1.fits'))
self.hdus.writeto(filename)
with catch_warnings() as l:
t = Table.read(filename, hdu=hdu)
assert len(l) == 0
assert equal_data(t, self.data1)
@pytest.mark.parametrize('hdu', [2, 'second'])
def test_read_with_hdu_2(self, tmpdir, hdu):
filename = str(tmpdir.join('test_read_with_hdu_2.fits'))
self.hdus.writeto(filename)
with catch_warnings() as l:
t = Table.read(filename, hdu=hdu)
assert len(l) == 0
assert equal_data(t, self.data2)
def test_read_from_hdulist(self):
with catch_warnings() as l:
t = Table.read(self.hdus)
assert len(l) == 1
assert str(l[0].message).startswith(
'hdu= was not specified but multiple tables are present, reading in first available table (hdu=1)')
assert equal_data(t, self.data1)
def test_read_from_hdulist_with_hdu_0(self, tmpdir):
with pytest.raises(ValueError) as exc:
Table.read(self.hdus, hdu=0)
assert exc.value.args[0] == 'No table found in hdu=0'
@pytest.mark.parametrize('hdu', [1, 'first'])
def test_read_from_hdulist_with_hdu_1(self, tmpdir, hdu):
with catch_warnings() as l:
t = Table.read(self.hdus, hdu=hdu)
assert len(l) == 0
assert equal_data(t, self.data1)
@pytest.mark.parametrize('hdu', [2, 'second'])
def test_read_from_hdulist_with_hdu_2(self, tmpdir, hdu):
with catch_warnings() as l:
t = Table.read(self.hdus, hdu=hdu)
assert len(l) == 0
assert equal_data(t, self.data2)
def test_read_from_single_hdu(self):
with catch_warnings() as l:
t = Table.read(self.hdus[1])
assert len(l) == 0
assert equal_data(t, self.data1)