Add files using upload-large-folder tool

testbed/astropy__astropy/astropy/io/__init__.py

@@ -0,0 +1,5 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+"""
+This subpackage contains modules and packages for interpreting data storage
+formats used by and in astropy.
+"""

testbed/astropy__astropy/astropy/io/fits/__init__.py

@@ -0,0 +1,89 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+"""
+A package for reading and writing FITS files and manipulating their
+contents.
+
+A module for reading and writing Flexible Image Transport System
+(FITS) files.  This file format was endorsed by the International
+Astronomical Union in 1999 and mandated by NASA as the standard format
+for storing high energy astrophysics data.  For details of the FITS
+standard, see the NASA/Science Office of Standards and Technology
+publication, NOST 100-2.0.
+"""
+
+from astropy import config as _config
+
+# Set module-global boolean variables
+# TODO: Make it possible to set these variables via environment variables
+# again, once support for that is added to Astropy
+
+
+class Conf(_config.ConfigNamespace):
+    """
+    Configuration parameters for `astropy.io.fits`.
+    """
+
+    enable_record_valued_keyword_cards = _config.ConfigItem(
+        True,
+        'If True, enable support for record-valued keywords as described by '
+        'FITS WCS distortion paper. Otherwise they are treated as normal '
+        'keywords.',
+        aliases=['astropy.io.fits.enabled_record_valued_keyword_cards'])
+    extension_name_case_sensitive = _config.ConfigItem(
+        False,
+        'If True, extension names (i.e. the ``EXTNAME`` keyword) should be '
+        'treated as case-sensitive.')
+    strip_header_whitespace = _config.ConfigItem(
+        True,
+        'If True, automatically remove trailing whitespace for string values in '
+        'headers.  Otherwise the values are returned verbatim, with all '
+        'whitespace intact.')
+    use_memmap = _config.ConfigItem(
+        True,
+        'If True, use memory-mapped file access to read/write the data in '
+        'FITS files. This generally provides better performance, especially '
+        'for large files, but may affect performance in I/O-heavy '
+        'applications.')
+    lazy_load_hdus = _config.ConfigItem(
+        True,
+        'If True, use lazy loading of HDUs when opening FITS files by '
+        'default; that is fits.open() will only seek for and read HDUs on '
+        'demand rather than reading all HDUs at once.  See the documentation '
+        'for fits.open() for more datails.')
+    enable_uint = _config.ConfigItem(
+        True,
+        'If True, default to recognizing the convention for representing '
+        'unsigned integers in FITS--if an array has BITPIX > 0, BSCALE = 1, '
+        'and BZERO = 2**BITPIX, represent the data as unsigned integers '
+        'per this convention.')
+
+
+conf = Conf()
+
+
+# Public API compatibility imports
+# These need to come after the global config variables, as some of the
+# submodules use them
+from . import card
+from . import column
+from . import convenience
+from . import hdu
+from .card import *
+from .column import *
+from .convenience import *
+from .diff import *
+from .fitsrec import FITS_record, FITS_rec
+from .hdu import *
+
+from .hdu.groups import GroupData
+from .hdu.hdulist import fitsopen as open
+from .hdu.image import Section
+from .header import Header
+from .verify import VerifyError
+
+
+__all__ = (['Conf', 'conf'] + card.__all__ + column.__all__ +
+           convenience.__all__ + hdu.__all__ +
+           ['FITS_record', 'FITS_rec', 'GroupData', 'open', 'Section',
+            'Header', 'VerifyError', 'conf'])

testbed/astropy__astropy/astropy/io/fits/_utils.pyx

@@ -0,0 +1,65 @@
+# cython: language_level=3
+from collections import OrderedDict
+
+cdef Py_ssize_t BLOCK_SIZE = 2880  # the FITS block size
+cdef Py_ssize_t CARD_LENGTH = 80
+cdef str VALUE_INDICATOR = '= '  # The standard FITS value indicator
+cdef str END_CARD = 'END' + ' ' * 77
+
+
+def parse_header(fileobj):
+    """Fast (and incomplete) parser for FITS headers.
+
+    This parser only reads the standard 8 character keywords, and ignores the
+    CONTINUE, COMMENT, HISTORY and HIERARCH cards. The goal is to find quickly
+    the structural keywords needed to build the HDU objects.
+
+    The implementation is straightforward: first iterate on the 2880-bytes
+    blocks, then iterate on the 80-bytes cards, find the value separator, and
+    store the parsed (keyword, card image) in a dictionary.
+
+    """
+
+    cards = OrderedDict()
+    cdef list read_blocks = []
+    cdef int found_end = 0
+    cdef bytes block
+    cdef str header_str, block_str, card_image, keyword
+    cdef Py_ssize_t idx, end_idx, sep_idx
+
+    while found_end == 0:
+        # iterate on blocks
+        block = fileobj.read(BLOCK_SIZE)
+        if not block or len(block) < BLOCK_SIZE:
+            # header looks incorrect, raising exception to fall back to
+            # the full Header parsing
+            raise Exception
+
+        block_str = block.decode('ascii')
+        read_blocks.append(block_str)
+        idx = 0
+        while idx < BLOCK_SIZE:
+            # iterate on cards
+            end_idx = idx + CARD_LENGTH
+            card_image = block_str[idx:end_idx]
+            idx = end_idx
+
+            # We are interested only in standard keyword, so we skip
+            # other cards, e.g. CONTINUE, HIERARCH, COMMENT.
+            if card_image[8:10] == VALUE_INDICATOR:
+                # ok, found standard keyword
+                keyword = card_image[:8].strip()
+                cards[keyword.upper()] = card_image
+            else:
+                sep_idx = card_image.find(VALUE_INDICATOR, 0, 8)
+                if sep_idx > 0:
+                    keyword = card_image[:sep_idx]
+                    cards[keyword.upper()] = card_image
+                elif card_image == END_CARD:
+                    found_end = 1
+                    break
+
+    # we keep the full header string as it may be needed later to
+    # create a Header object
+    header_str = ''.join(read_blocks)
+    return header_str, cards

testbed/astropy__astropy/astropy/io/fits/card.py

@@ -0,0 +1,1292 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import re
+import warnings
+
+import numpy as np
+
+from .util import _str_to_num, _is_int, translate, _words_group
+from .verify import _Verify, _ErrList, VerifyError, VerifyWarning
+
+from . import conf
+from astropy.utils.exceptions import AstropyUserWarning
+
+
+__all__ = ['Card', 'Undefined']
+
+
+FIX_FP_TABLE = str.maketrans('de', 'DE')
+FIX_FP_TABLE2 = str.maketrans('dD', 'eE')
+
+
+CARD_LENGTH = 80
+BLANK_CARD = ' ' * CARD_LENGTH
+KEYWORD_LENGTH = 8  # The max length for FITS-standard keywords
+
+VALUE_INDICATOR = '= '  # The standard FITS value indicator
+VALUE_INDICATOR_LEN = len(VALUE_INDICATOR)
+HIERARCH_VALUE_INDICATOR = '='  # HIERARCH cards may use a shortened indicator
+
+
+class Undefined:
+    """Undefined value."""
+
+    def __init__(self):
+        # This __init__ is required to be here for Sphinx documentation
+        pass
+
+
+UNDEFINED = Undefined()
+
+
+class Card(_Verify):
+
+    length = CARD_LENGTH
+    """The length of a Card image; should always be 80 for valid FITS files."""
+
+    # String for a FITS standard compliant (FSC) keyword.
+    _keywd_FSC_RE = re.compile(r'^[A-Z0-9_-]{0,%d}$' % KEYWORD_LENGTH)
+    # This will match any printable ASCII character excluding '='
+    _keywd_hierarch_RE = re.compile(r'^(?:HIERARCH +)?(?:^[ -<>-~]+ ?)+$',
+                                    re.I)
+
+    # A number sub-string, either an integer or a float in fixed or
+    # scientific notation.  One for FSC and one for non-FSC (NFSC) format:
+    # NFSC allows lower case of DE for exponent, allows space between sign,
+    # digits, exponent sign, and exponents
+    _digits_FSC = r'(\.\d+|\d+(\.\d*)?)([DE][+-]?\d+)?'
+    _digits_NFSC = r'(\.\d+|\d+(\.\d*)?) *([deDE] *[+-]? *\d+)?'
+    _numr_FSC = r'[+-]?' + _digits_FSC
+    _numr_NFSC = r'[+-]? *' + _digits_NFSC
+
+    # This regex helps delete leading zeros from numbers, otherwise
+    # Python might evaluate them as octal values (this is not-greedy, however,
+    # so it may not strip leading zeros from a float, which is fine)
+    _number_FSC_RE = re.compile(r'(?P<sign>[+-])?0*?(?P<digt>{})'.format(
+            _digits_FSC))
+    _number_NFSC_RE = re.compile(r'(?P<sign>[+-])? *0*?(?P<digt>{})'.format(
+            _digits_NFSC))
+
+    # FSC commentary card string which must contain printable ASCII characters.
+    # Note: \Z matches the end of the string without allowing newlines
+    _ascii_text_re = re.compile(r'[ -~]*\Z')
+
+    # Checks for a valid value/comment string.  It returns a match object
+    # for a valid value/comment string.
+    # The valu group will return a match if a FITS string, boolean,
+    # number, or complex value is found, otherwise it will return
+    # None, meaning the keyword is undefined.  The comment field will
+    # return a match if the comment separator is found, though the
+    # comment maybe an empty string.
+    _value_FSC_RE = re.compile(
+        r'(?P<valu_field> *'
+            r'(?P<valu>'
+
+                #  The <strg> regex is not correct for all cases, but
+                #  it comes pretty darn close.  It appears to find the
+                #  end of a string rather well, but will accept
+                #  strings with an odd number of single quotes,
+                #  instead of issuing an error.  The FITS standard
+                #  appears vague on this issue and only states that a
+                #  string should not end with two single quotes,
+                #  whereas it should not end with an even number of
+                #  quotes to be precise.
+                #
+                #  Note that a non-greedy match is done for a string,
+                #  since a greedy match will find a single-quote after
+                #  the comment separator resulting in an incorrect
+                #  match.
+                r'\'(?P<strg>([ -~]+?|\'\'|)) *?\'(?=$|/| )|'
+                r'(?P<bool>[FT])|'
+                r'(?P<numr>' + _numr_FSC + r')|'
+                r'(?P<cplx>\( *'
+                    r'(?P<real>' + _numr_FSC + r') *, *'
+                    r'(?P<imag>' + _numr_FSC + r') *\))'
+            r')? *)'
+        r'(?P<comm_field>'
+            r'(?P<sepr>/ *)'
+            r'(?P<comm>[!-~][ -~]*)?'
+        r')?$')
+
+    _value_NFSC_RE = re.compile(
+        r'(?P<valu_field> *'
+            r'(?P<valu>'
+                r'\'(?P<strg>([ -~]+?|\'\'|) *?)\'(?=$|/| )|'
+                r'(?P<bool>[FT])|'
+                r'(?P<numr>' + _numr_NFSC + r')|'
+                r'(?P<cplx>\( *'
+                    r'(?P<real>' + _numr_NFSC + r') *, *'
+                    r'(?P<imag>' + _numr_NFSC + r') *\))'
+            r')? *)'
+        r'(?P<comm_field>'
+            r'(?P<sepr>/ *)'
+            r'(?P<comm>(.|\n)*)'
+        r')?$')
+
+    _rvkc_identifier = r'[a-zA-Z_]\w*'
+    _rvkc_field = _rvkc_identifier + r'(\.\d+)?'
+    _rvkc_field_specifier_s = r'{}(\.{})*'.format(_rvkc_field, _rvkc_field)
+    _rvkc_field_specifier_val = (r'(?P<keyword>{}): (?P<val>{})'.format(
+            _rvkc_field_specifier_s, _numr_FSC))
+    _rvkc_keyword_val = r'\'(?P<rawval>{})\''.format(_rvkc_field_specifier_val)
+    _rvkc_keyword_val_comm = (r' *{} *(/ *(?P<comm>[ -~]*))?$'.format(
+            _rvkc_keyword_val))
+
+    _rvkc_field_specifier_val_RE = re.compile(_rvkc_field_specifier_val + '$')
+
+    # regular expression to extract the key and the field specifier from a
+    # string that is being used to index into a card list that contains
+    # record value keyword cards (ex. 'DP1.AXIS.1')
+    _rvkc_keyword_name_RE = (
+        re.compile(r'(?P<keyword>{})\.(?P<field_specifier>{})$'.format(
+                _rvkc_identifier, _rvkc_field_specifier_s)))
+
+    # regular expression to extract the field specifier and value and comment
+    # from the string value of a record value keyword card
+    # (ex "'AXIS.1: 1' / a comment")
+    _rvkc_keyword_val_comm_RE = re.compile(_rvkc_keyword_val_comm)
+
+    _commentary_keywords = {'', 'COMMENT', 'HISTORY', 'END'}
+    _special_keywords = _commentary_keywords.union(['CONTINUE'])
+
+    # The default value indicator; may be changed if required by a convention
+    # (namely HIERARCH cards)
+    _value_indicator = VALUE_INDICATOR
+
+    def __init__(self, keyword=None, value=None, comment=None, **kwargs):
+        # For backwards compatibility, support the 'key' keyword argument:
+        if keyword is None and 'key' in kwargs:
+            keyword = kwargs['key']
+
+        self._keyword = None
+        self._value = None
+        self._comment = None
+        self._valuestring = None
+        self._image = None
+
+        # This attribute is set to False when creating the card from a card
+        # image to ensure that the contents of the image get verified at some
+        # point
+        self._verified = True
+
+        # A flag to conveniently mark whether or not this was a valid HIERARCH
+        # card
+        self._hierarch = False
+
+        # If the card could not be parsed according the the FITS standard or
+        # any recognized non-standard conventions, this will be True
+        self._invalid = False
+
+        self._field_specifier = None
+
+        # These are used primarily only by RVKCs
+        self._rawkeyword = None
+        self._rawvalue = None
+
+        if not (keyword is not None and value is not None and
+                self._check_if_rvkc(keyword, value)):
+            # If _check_if_rvkc passes, it will handle setting the keyword and
+            # value
+            if keyword is not None:
+                self.keyword = keyword
+            if value is not None:
+                self.value = value
+
+        if comment is not None:
+            self.comment = comment
+
+        self._modified = False
+        self._valuemodified = False
+
+    def __repr__(self):
+        return repr((self.keyword, self.value, self.comment))
+
+    def __str__(self):
+        return self.image
+
+    def __len__(self):
+        return 3
+
+    def __getitem__(self, index):
+        return (self.keyword, self.value, self.comment)[index]
+
+    @property
+    def keyword(self):
+        """Returns the keyword name parsed from the card image."""
+        if self._keyword is not None:
+            return self._keyword
+        elif self._image:
+            self._keyword = self._parse_keyword()
+            return self._keyword
+        else:
+            self.keyword = ''
+            return ''
+
+    @keyword.setter
+    def keyword(self, keyword):
+        """Set the key attribute; once set it cannot be modified."""
+        if self._keyword is not None:
+            raise AttributeError(
+                'Once set, the Card keyword may not be modified')
+        elif isinstance(keyword, str):
+            # Be nice and remove trailing whitespace--some FITS code always
+            # pads keywords out with spaces; leading whitespace, however,
+            # should be strictly disallowed.
+            keyword = keyword.rstrip()
+            keyword_upper = keyword.upper()
+            if (len(keyword) <= KEYWORD_LENGTH and
+                self._keywd_FSC_RE.match(keyword_upper)):
+                # For keywords with length > 8 they will be HIERARCH cards,
+                # and can have arbitrary case keywords
+                if keyword_upper == 'END':
+                    raise ValueError("Keyword 'END' not allowed.")
+                keyword = keyword_upper
+            elif self._keywd_hierarch_RE.match(keyword):
+                # In prior versions of PyFITS (*) HIERARCH cards would only be
+                # created if the user-supplied keyword explicitly started with
+                # 'HIERARCH '.  Now we will create them automatically for long
+                # keywords, but we still want to support the old behavior too;
+                # the old behavior makes it possible to create HEIRARCH cards
+                # that would otherwise be recognized as RVKCs
+                # (*) This has never affected Astropy, because it was changed
+                # before PyFITS was merged into Astropy!
+                self._hierarch = True
+                self._value_indicator = HIERARCH_VALUE_INDICATOR
+
+                if keyword_upper[:9] == 'HIERARCH ':
+                    # The user explicitly asked for a HIERARCH card, so don't
+                    # bug them about it...
+                    keyword = keyword[9:].strip()
+                else:
+                    # We'll gladly create a HIERARCH card, but a warning is
+                    # also displayed
+                    warnings.warn(
+                        'Keyword name {!r} is greater than 8 characters or '
+                        'contains characters not allowed by the FITS '
+                        'standard; a HIERARCH card will be created.'.format(
+                            keyword), VerifyWarning)
+            else:
+                raise ValueError('Illegal keyword name: {!r}.'.format(keyword))
+            self._keyword = keyword
+            self._modified = True
+        else:
+            raise ValueError('Keyword name {!r} is not a string.'.format(keyword))
+
+    @property
+    def value(self):
+        """The value associated with the keyword stored in this card."""
+
+        if self.field_specifier:
+            return float(self._value)
+
+        if self._value is not None:
+            value = self._value
+        elif self._valuestring is not None or self._image:
+            value = self._value = self._parse_value()
+        else:
+            if self._keyword == '':
+                self._value = value = ''
+            else:
+                self._value = value = UNDEFINED
+
+        if conf.strip_header_whitespace and isinstance(value, str):
+            value = value.rstrip()
+
+        return value
+
+    @value.setter
+    def value(self, value):
+        if self._invalid:
+            raise ValueError(
+                'The value of invalid/unparseable cards cannot set.  Either '
+                'delete this card from the header or replace it.')
+
+        if value is None:
+            value = UNDEFINED
+
+        try:
+            oldvalue = self.value
+        except VerifyError:
+            # probably a parsing error, falling back to the internal _value
+            # which should be None. This may happen while calling _fix_value.
+            oldvalue = self._value
+
+        if oldvalue is None:
+            oldvalue = UNDEFINED
+
+        if not isinstance(value,
+                          (str, int, float, complex, bool, Undefined,
+                           np.floating, np.integer, np.complexfloating,
+                           np.bool_)):
+            raise ValueError('Illegal value: {!r}.'.format(value))
+
+        if isinstance(value, float) and (np.isnan(value) or np.isinf(value)):
+            raise ValueError("Floating point {!r} values are not allowed "
+                             "in FITS headers.".format(value))
+
+        elif isinstance(value, str):
+            m = self._ascii_text_re.match(value)
+            if not m:
+                raise ValueError(
+                    'FITS header values must contain standard printable ASCII '
+                    'characters; {!r} contains characters not representable in '
+                    'ASCII or non-printable characters.'.format(value))
+        elif isinstance(value, bytes):
+            # Allow str, but only if they can be decoded to ASCII text; note
+            # this is not even allowed on Python 3 since the `bytes` type is
+            # not included in `str`.  Presently we simply don't
+            # allow bytes to be assigned to headers, as doing so would too
+            # easily mask potential user error
+            valid = True
+            try:
+                text_value = value.decode('ascii')
+            except UnicodeDecodeError:
+                valid = False
+            else:
+                # Check against the printable characters regexp as well
+                m = self._ascii_text_re.match(text_value)
+                valid = m is not None
+
+            if not valid:
+                raise ValueError(
+                    'FITS header values must contain standard printable ASCII '
+                    'characters; {!r} contains characters/bytes that do not '
+                    'represent printable characters in ASCII.'.format(value))
+        elif isinstance(value, np.bool_):
+            value = bool(value)
+
+        if (conf.strip_header_whitespace and
+            (isinstance(oldvalue, str) and isinstance(value, str))):
+            # Ignore extra whitespace when comparing the new value to the old
+            different = oldvalue.rstrip() != value.rstrip()
+        elif isinstance(oldvalue, bool) or isinstance(value, bool):
+            different = oldvalue is not value
+        else:
+            different = (oldvalue != value or
+                         not isinstance(value, type(oldvalue)))
+
+        if different:
+            self._value = value
+            self._rawvalue = None
+            self._modified = True
+            self._valuestring = None
+            self._valuemodified = True
+            if self.field_specifier:
+                try:
+                    self._value = _int_or_float(self._value)
+                except ValueError:
+                    raise ValueError('value {} is not a float'.format(
+                            self._value))
+
+    @value.deleter
+    def value(self):
+        if self._invalid:
+            raise ValueError(
+                'The value of invalid/unparseable cards cannot deleted.  '
+                'Either delete this card from the header or replace it.')
+
+        if not self.field_specifier:
+            self.value = ''
+        else:
+            raise AttributeError('Values cannot be deleted from record-valued '
+                                 'keyword cards')
+
+    @property
+    def rawkeyword(self):
+        """On record-valued keyword cards this is the name of the standard <= 8
+        character FITS keyword that this RVKC is stored in.  Otherwise it is
+        the card's normal keyword.
+        """
+
+        if self._rawkeyword is not None:
+            return self._rawkeyword
+        elif self.field_specifier is not None:
+            self._rawkeyword = self.keyword.split('.', 1)[0]
+            return self._rawkeyword
+        else:
+            return self.keyword
+
+    @property
+    def rawvalue(self):
+        """On record-valued keyword cards this is the raw string value in
+        the ``<field-specifier>: <value>`` format stored in the card in order
+        to represent a RVKC.  Otherwise it is the card's normal value.
+        """
+
+        if self._rawvalue is not None:
+            return self._rawvalue
+        elif self.field_specifier is not None:
+            self._rawvalue = '{}: {}'.format(self.field_specifier, self.value)
+            return self._rawvalue
+        else:
+            return self.value
+
+    @property
+    def comment(self):
+        """Get the comment attribute from the card image if not already set."""
+
+        if self._comment is not None:
+            return self._comment
+        elif self._image:
+            self._comment = self._parse_comment()
+            return self._comment
+        else:
+            self._comment = ''
+            return ''
+
+    @comment.setter
+    def comment(self, comment):
+        if self._invalid:
+            raise ValueError(
+                'The comment of invalid/unparseable cards cannot set.  Either '
+                'delete this card from the header or replace it.')
+
+        if comment is None:
+            comment = ''
+
+        if isinstance(comment, str):
+            m = self._ascii_text_re.match(comment)
+            if not m:
+                raise ValueError(
+                    'FITS header comments must contain standard printable '
+                    'ASCII characters; {!r} contains characters not '
+                    'representable in ASCII or non-printable characters.'
+                    .format(comment))
+
+        try:
+            oldcomment = self.comment
+        except VerifyError:
+            # probably a parsing error, falling back to the internal _comment
+            # which should be None.
+            oldcomment = self._comment
+
+        if oldcomment is None:
+            oldcomment = ''
+        if comment != oldcomment:
+            self._comment = comment
+            self._modified = True
+
+    @comment.deleter
+    def comment(self):
+        if self._invalid:
+            raise ValueError(
+                'The comment of invalid/unparseable cards cannot deleted.  '
+                'Either delete this card from the header or replace it.')
+
+        self.comment = ''
+
+    @property
+    def field_specifier(self):
+        """
+        The field-specifier of record-valued keyword cards; always `None` on
+        normal cards.
+        """
+
+        # Ensure that the keyword exists and has been parsed--the will set the
+        # internal _field_specifier attribute if this is a RVKC.
+        if self.keyword:
+            return self._field_specifier
+        else:
+            return None
+
+    @field_specifier.setter
+    def field_specifier(self, field_specifier):
+        if not field_specifier:
+            raise ValueError('The field-specifier may not be blank in '
+                             'record-valued keyword cards.')
+        elif not self.field_specifier:
+            raise AttributeError('Cannot coerce cards to be record-valued '
+                                 'keyword cards by setting the '
+                                 'field_specifier attribute')
+        elif field_specifier != self.field_specifier:
+            self._field_specifier = field_specifier
+            # The keyword need also be updated
+            keyword = self._keyword.split('.', 1)[0]
+            self._keyword = '.'.join([keyword, field_specifier])
+            self._modified = True
+
+    @field_specifier.deleter
+    def field_specifier(self):
+        raise AttributeError('The field_specifier attribute may not be '
+                             'deleted from record-valued keyword cards.')
+
+    @property
+    def image(self):
+        """
+        The card "image", that is, the 80 byte character string that represents
+        this card in an actual FITS header.
+        """
+
+        if self._image and not self._verified:
+            self.verify('fix+warn')
+        if self._image is None or self._modified:
+            self._image = self._format_image()
+        return self._image
+
+    @property
+    def is_blank(self):
+        """
+        `True` if the card is completely blank--that is, it has no keyword,
+        value, or comment.  It appears in the header as 80 spaces.
+
+        Returns `False` otherwise.
+        """
+
+        if not self._verified:
+            # The card image has not been parsed yet; compare directly with the
+            # string representation of a blank card
+            return self._image == BLANK_CARD
+
+        # If the keyword, value, and comment are all empty (for self.value
+        # explicitly check that it is a string value, since a blank value is
+        # returned as '')
+        return (not self.keyword and
+                (isinstance(self.value, str) and not self.value) and
+                not self.comment)
+
+    @classmethod
+    def fromstring(cls, image):
+        """
+        Construct a `Card` object from a (raw) string. It will pad the string
+        if it is not the length of a card image (80 columns).  If the card
+        image is longer than 80 columns, assume it contains ``CONTINUE``
+        card(s).
+        """
+
+        card = cls()
+        if isinstance(image, bytes):
+            # FITS supports only ASCII, but decode as latin1 and just take all
+            # bytes for now; if it results in mojibake due to e.g. UTF-8
+            # encoded data in a FITS header that's OK because it shouldn't be
+            # there in the first place
+            image = image.decode('latin1')
+
+        card._image = _pad(image)
+        card._verified = False
+        return card
+
+    @classmethod
+    def normalize_keyword(cls, keyword):
+        """
+        `classmethod` to convert a keyword value that may contain a
+        field-specifier to uppercase.  The effect is to raise the key to
+        uppercase and leave the field specifier in its original case.
+
+        Parameters
+        ----------
+        keyword : or str
+            A keyword value or a ``keyword.field-specifier`` value
+        """
+
+        # Test first for the most common case: a standard FITS keyword provided
+        # in standard all-caps
+        if (len(keyword) <= KEYWORD_LENGTH and
+                cls._keywd_FSC_RE.match(keyword)):
+            return keyword
+
+        # Test if this is a record-valued keyword
+        match = cls._rvkc_keyword_name_RE.match(keyword)
+
+        if match:
+            return '.'.join((match.group('keyword').strip().upper(),
+                             match.group('field_specifier')))
+        elif len(keyword) > 9 and keyword[:9].upper() == 'HIERARCH ':
+            # Remove 'HIERARCH' from HIERARCH keywords; this could lead to
+            # ambiguity if there is actually a keyword card containing
+            # "HIERARCH HIERARCH", but shame on you if you do that.
+            return keyword[9:].strip().upper()
+        else:
+            # A normal FITS keyword, but provided in non-standard case
+            return keyword.strip().upper()
+
+    def _check_if_rvkc(self, *args):
+        """
+        Determine whether or not the card is a record-valued keyword card.
+
+        If one argument is given, that argument is treated as a full card image
+        and parsed as such.  If two arguments are given, the first is treated
+        as the card keyword (including the field-specifier if the card is
+        intended as a RVKC), and the second as the card value OR the first value
+        can be the base keyword, and the second value the 'field-specifier:
+        value' string.
+
+        If the check passes the ._keyword, ._value, and .field_specifier
+        keywords are set.
+
+        Examples
+        --------
+
+        ::
+
+            self._check_if_rvkc('DP1', 'AXIS.1: 2')
+            self._check_if_rvkc('DP1.AXIS.1', 2)
+            self._check_if_rvkc('DP1     = AXIS.1: 2')
+        """
+
+        if not conf.enable_record_valued_keyword_cards:
+            return False
+
+        if len(args) == 1:
+            return self._check_if_rvkc_image(*args)
+        elif len(args) == 2:
+            keyword, value = args
+            if not isinstance(keyword, str):
+                return False
+            if keyword in self._commentary_keywords:
+                return False
+            match = self._rvkc_keyword_name_RE.match(keyword)
+            if match and isinstance(value, (int, float)):
+                self._init_rvkc(match.group('keyword'),
+                                match.group('field_specifier'), None, value)
+                return True
+
+            # Testing for ': ' is a quick way to avoid running the full regular
+            # expression, speeding this up for the majority of cases
+            if isinstance(value, str) and value.find(': ') > 0:
+                match = self._rvkc_field_specifier_val_RE.match(value)
+                if match and self._keywd_FSC_RE.match(keyword):
+                    self._init_rvkc(keyword, match.group('keyword'), value,
+                                    match.group('val'))
+                    return True
+
+    def _check_if_rvkc_image(self, *args):
+        """
+        Implements `Card._check_if_rvkc` for the case of an unparsed card
+        image.  If given one argument this is the full intact image.  If given
+        two arguments the card has already been split between keyword and
+        value+comment at the standard value indicator '= '.
+        """
+
+        if len(args) == 1:
+            image = args[0]
+            eq_idx = image.find(VALUE_INDICATOR)
+            if eq_idx < 0 or eq_idx > 9:
+                return False
+            keyword = image[:eq_idx]
+            rest = image[eq_idx + VALUE_INDICATOR_LEN:]
+        else:
+            keyword, rest = args
+
+        rest = rest.lstrip()
+
+        # This test allows us to skip running the full regular expression for
+        # the majority of cards that do not contain strings or that definitely
+        # do not contain RVKC field-specifiers; it's very much a
+        # micro-optimization but it does make a measurable difference
+        if not rest or rest[0] != "'" or rest.find(': ') < 2:
+            return False
+
+        match = self._rvkc_keyword_val_comm_RE.match(rest)
+        if match:
+            self._init_rvkc(keyword, match.group('keyword'),
+                            match.group('rawval'), match.group('val'))
+            return True
+
+    def _init_rvkc(self, keyword, field_specifier, field, value):
+        """
+        Sort of addendum to Card.__init__ to set the appropriate internal
+        attributes if the card was determined to be a RVKC.
+        """
+
+        keyword_upper = keyword.upper()
+        self._keyword = '.'.join((keyword_upper, field_specifier))
+        self._rawkeyword = keyword_upper
+        self._field_specifier = field_specifier
+        self._value = _int_or_float(value)
+        self._rawvalue = field
+
+    def _parse_keyword(self):
+        keyword = self._image[:KEYWORD_LENGTH].strip()
+        keyword_upper = keyword.upper()
+
+        if keyword_upper in self._special_keywords:
+            return keyword_upper
+        elif (keyword_upper == 'HIERARCH' and self._image[8] == ' ' and
+              HIERARCH_VALUE_INDICATOR in self._image):
+            # This is valid HIERARCH card as described by the HIERARCH keyword
+            # convention:
+            # http://fits.gsfc.nasa.gov/registry/hierarch_keyword.html
+            self._hierarch = True
+            self._value_indicator = HIERARCH_VALUE_INDICATOR
+            keyword = self._image.split(HIERARCH_VALUE_INDICATOR, 1)[0][9:]
+            return keyword.strip()
+        else:
+            val_ind_idx = self._image.find(VALUE_INDICATOR)
+            if 0 <= val_ind_idx <= KEYWORD_LENGTH:
+                # The value indicator should appear in byte 8, but we are
+                # flexible and allow this to be fixed
+                if val_ind_idx < KEYWORD_LENGTH:
+                    keyword = keyword[:val_ind_idx]
+                    keyword_upper = keyword_upper[:val_ind_idx]
+
+                rest = self._image[val_ind_idx + VALUE_INDICATOR_LEN:]
+
+                # So far this looks like a standard FITS keyword; check whether
+                # the value represents a RVKC; if so then we pass things off to
+                # the RVKC parser
+                if self._check_if_rvkc_image(keyword, rest):
+                    return self._keyword
+
+                return keyword_upper
+            else:
+                warnings.warn(
+                    'The following header keyword is invalid or follows an '
+                    'unrecognized non-standard convention:\n{}'
+                    .format(self._image), AstropyUserWarning)
+                self._invalid = True
+                return keyword
+
+    def _parse_value(self):
+        """Extract the keyword value from the card image."""
+
+        # for commentary cards, no need to parse further
+        # Likewise for invalid cards
+        if self.keyword.upper() in self._commentary_keywords or self._invalid:
+            return self._image[KEYWORD_LENGTH:].rstrip()
+
+        if self._check_if_rvkc(self._image):
+            return self._value
+
+        if len(self._image) > self.length:
+            values = []
+            for card in self._itersubcards():
+                value = card.value.rstrip().replace("''", "'")
+                if value and value[-1] == '&':
+                    value = value[:-1]
+                values.append(value)
+
+            value = ''.join(values)
+
+            self._valuestring = value
+            return value
+
+        m = self._value_NFSC_RE.match(self._split()[1])
+
+        if m is None:
+            raise VerifyError("Unparsable card ({}), fix it first with "
+                              ".verify('fix').".format(self.keyword))
+
+        if m.group('bool') is not None:
+            value = m.group('bool') == 'T'
+        elif m.group('strg') is not None:
+            value = re.sub("''", "'", m.group('strg'))
+        elif m.group('numr') is not None:
+            #  Check for numbers with leading 0s.
+            numr = self._number_NFSC_RE.match(m.group('numr'))
+            digt = translate(numr.group('digt'), FIX_FP_TABLE2, ' ')
+            if numr.group('sign') is None:
+                sign = ''
+            else:
+                sign = numr.group('sign')
+            value = _str_to_num(sign + digt)
+
+        elif m.group('cplx') is not None:
+            #  Check for numbers with leading 0s.
+            real = self._number_NFSC_RE.match(m.group('real'))
+            rdigt = translate(real.group('digt'), FIX_FP_TABLE2, ' ')
+            if real.group('sign') is None:
+                rsign = ''
+            else:
+                rsign = real.group('sign')
+            value = _str_to_num(rsign + rdigt)
+            imag = self._number_NFSC_RE.match(m.group('imag'))
+            idigt = translate(imag.group('digt'), FIX_FP_TABLE2, ' ')
+            if imag.group('sign') is None:
+                isign = ''
+            else:
+                isign = imag.group('sign')
+            value += _str_to_num(isign + idigt) * 1j
+        else:
+            value = UNDEFINED
+
+        if not self._valuestring:
+            self._valuestring = m.group('valu')
+        return value
+
+    def _parse_comment(self):
+        """Extract the keyword value from the card image."""
+
+        # for commentary cards, no need to parse further
+        # likewise for invalid/unparseable cards
+        if self.keyword in Card._commentary_keywords or self._invalid:
+            return ''
+
+        if len(self._image) > self.length:
+            comments = []
+            for card in self._itersubcards():
+                if card.comment:
+                    comments.append(card.comment)
+            comment = '/ ' + ' '.join(comments).rstrip()
+            m = self._value_NFSC_RE.match(comment)
+        else:
+            m = self._value_NFSC_RE.match(self._split()[1])
+
+        if m is not None:
+            comment = m.group('comm')
+            if comment:
+                return comment.rstrip()
+        return ''
+
+    def _split(self):
+        """
+        Split the card image between the keyword and the rest of the card.
+        """
+
+        if self._image is not None:
+            # If we already have a card image, don't try to rebuild a new card
+            # image, which self.image would do
+            image = self._image
+        else:
+            image = self.image
+
+        if self.keyword in self._special_keywords:
+            keyword, valuecomment = image.split(' ', 1)
+        else:
+            try:
+                delim_index = image.index(self._value_indicator)
+            except ValueError:
+                delim_index = None
+
+            # The equal sign may not be any higher than column 10; anything
+            # past that must be considered part of the card value
+            if delim_index is None:
+                keyword = image[:KEYWORD_LENGTH]
+                valuecomment = image[KEYWORD_LENGTH:]
+            elif delim_index > 10 and image[:9] != 'HIERARCH ':
+                keyword = image[:8]
+                valuecomment = image[8:]
+            else:
+                keyword, valuecomment = image.split(self._value_indicator, 1)
+        return keyword.strip(), valuecomment.strip()
+
+    def _fix_keyword(self):
+        if self.field_specifier:
+            keyword, field_specifier = self._keyword.split('.', 1)
+            self._keyword = '.'.join([keyword.upper(), field_specifier])
+        else:
+            self._keyword = self._keyword.upper()
+        self._modified = True
+
+    def _fix_value(self):
+        """Fix the card image for fixable non-standard compliance."""
+
+        value = None
+        keyword, valuecomment = self._split()
+        m = self._value_NFSC_RE.match(valuecomment)
+
+        # for the unparsable case
+        if m is None:
+            try:
+                value, comment = valuecomment.split('/', 1)
+                self.value = value.strip()
+                self.comment = comment.strip()
+            except (ValueError, IndexError):
+                self.value = valuecomment
+            self._valuestring = self._value
+            return
+        elif m.group('numr') is not None:
+            numr = self._number_NFSC_RE.match(m.group('numr'))
+            value = translate(numr.group('digt'), FIX_FP_TABLE, ' ')
+            if numr.group('sign') is not None:
+                value = numr.group('sign') + value
+
+        elif m.group('cplx') is not None:
+            real = self._number_NFSC_RE.match(m.group('real'))
+            rdigt = translate(real.group('digt'), FIX_FP_TABLE, ' ')
+            if real.group('sign') is not None:
+                rdigt = real.group('sign') + rdigt
+
+            imag = self._number_NFSC_RE.match(m.group('imag'))
+            idigt = translate(imag.group('digt'), FIX_FP_TABLE, ' ')
+            if imag.group('sign') is not None:
+                idigt = imag.group('sign') + idigt
+            value = '({}, {})'.format(rdigt, idigt)
+        self._valuestring = value
+        # The value itself has not been modified, but its serialized
+        # representation (as stored in self._valuestring) has been changed, so
+        # still set this card as having been modified (see ticket #137)
+        self._modified = True
+
+    def _format_keyword(self):
+        if self.keyword:
+            if self.field_specifier:
+                return '{:{len}}'.format(self.keyword.split('.', 1)[0],
+                                         len=KEYWORD_LENGTH)
+            elif self._hierarch:
+                return 'HIERARCH {} '.format(self.keyword)
+            else:
+                return '{:{len}}'.format(self.keyword, len=KEYWORD_LENGTH)
+        else:
+            return ' ' * KEYWORD_LENGTH
+
+    def _format_value(self):
+        # value string
+        float_types = (float, np.floating, complex, np.complexfloating)
+
+        # Force the value to be parsed out first
+        value = self.value
+        # But work with the underlying raw value instead (to preserve
+        # whitespace, for now...)
+        value = self._value
+
+        if self.keyword in self._commentary_keywords:
+            # The value of a commentary card must be just a raw unprocessed
+            # string
+            value = str(value)
+        elif (self._valuestring and not self._valuemodified and
+              isinstance(self.value, float_types)):
+            # Keep the existing formatting for float/complex numbers
+            value = '{:>20}'.format(self._valuestring)
+        elif self.field_specifier:
+            value = _format_value(self._value).strip()
+            value = "'{}: {}'".format(self.field_specifier, value)
+        else:
+            value = _format_value(value)
+
+        # For HIERARCH cards the value should be shortened to conserve space
+        if not self.field_specifier and len(self.keyword) > KEYWORD_LENGTH:
+            value = value.strip()
+
+        return value
+
+    def _format_comment(self):
+        if not self.comment:
+            return ''
+        else:
+            return ' / {}'.format(self._comment)
+
+    def _format_image(self):
+        keyword = self._format_keyword()
+
+        value = self._format_value()
+        is_commentary = keyword.strip() in self._commentary_keywords
+        if is_commentary:
+            comment = ''
+        else:
+            comment = self._format_comment()
+
+        # equal sign string
+        # by default use the standard value indicator even for HIERARCH cards;
+        # later we may abbreviate it if necessary
+        delimiter = VALUE_INDICATOR
+        if is_commentary:
+            delimiter = ''
+
+        # put all parts together
+        output = ''.join([keyword, delimiter, value, comment])
+
+        # For HIERARCH cards we can save a bit of space if necessary by
+        # removing the space between the keyword and the equals sign; I'm
+        # guessing this is part of the HIEARCH card specification
+        keywordvalue_length = len(keyword) + len(delimiter) + len(value)
+        if (keywordvalue_length > self.length and
+                keyword.startswith('HIERARCH')):
+            if (keywordvalue_length == self.length + 1 and keyword[-1] == ' '):
+                output = ''.join([keyword[:-1], delimiter, value, comment])
+            else:
+                # I guess the HIERARCH card spec is incompatible with CONTINUE
+                # cards
+                raise ValueError('The header keyword {!r} with its value is '
+                                 'too long'.format(self.keyword))
+
+        if len(output) <= self.length:
+            output = '{:80}'.format(output)
+        else:
+            # longstring case (CONTINUE card)
+            # try not to use CONTINUE if the string value can fit in one line.
+            # Instead, just truncate the comment
+            if (isinstance(self.value, str) and
+                len(value) > (self.length - 10)):
+                output = self._format_long_image()
+            else:
+                warnings.warn('Card is too long, comment will be truncated.',
+                              VerifyWarning)
+                output = output[:Card.length]
+        return output
+
+    def _format_long_image(self):
+        """
+        Break up long string value/comment into ``CONTINUE`` cards.
+        This is a primitive implementation: it will put the value
+        string in one block and the comment string in another.  Also,
+        it does not break at the blank space between words.  So it may
+        not look pretty.
+        """
+
+        if self.keyword in Card._commentary_keywords:
+            return self._format_long_commentary_image()
+
+        value_length = 67
+        comment_length = 64
+        output = []
+
+        # do the value string
+        value = self._value.replace("'", "''")
+        words = _words_group(value, value_length)
+        for idx, word in enumerate(words):
+            if idx == 0:
+                headstr = '{:{len}}= '.format(self.keyword, len=KEYWORD_LENGTH)
+            else:
+                headstr = 'CONTINUE  '
+
+            # If this is the final CONTINUE remove the '&'
+            if not self.comment and idx == len(words) - 1:
+                value_format = "'{}'"
+            else:
+                value_format = "'{}&'"
+
+            value = value_format.format(word)
+
+            output.append('{:80}'.format(headstr + value))
+
+        # do the comment string
+        comment_format = "{}"
+
+        if self.comment:
+            words = _words_group(self.comment, comment_length)
+            for idx, word in enumerate(words):
+                # If this is the final CONTINUE remove the '&'
+                if idx == len(words) - 1:
+                    headstr = "CONTINUE  '' / "
+                else:
+                    headstr = "CONTINUE  '&' / "
+
+                comment = headstr + comment_format.format(word)
+                output.append('{:80}'.format(comment))
+
+        return ''.join(output)
+
+    def _format_long_commentary_image(self):
+        """
+        If a commentary card's value is too long to fit on a single card, this
+        will render the card as multiple consecutive commentary card of the
+        same type.
+        """
+
+        maxlen = Card.length - KEYWORD_LENGTH
+        value = self._format_value()
+        output = []
+        idx = 0
+        while idx < len(value):
+            output.append(str(Card(self.keyword, value[idx:idx + maxlen])))
+            idx += maxlen
+        return ''.join(output)
+
+    def _verify(self, option='warn'):
+        self._verified = True
+
+        errs = _ErrList([])
+        fix_text = ('Fixed {!r} card to meet the FITS '
+                    'standard.'.format(self.keyword))
+
+        # Don't try to verify cards that already don't meet any recognizable
+        # standard
+        if self._invalid:
+            return errs
+
+        # verify the equal sign position
+        if (self.keyword not in self._commentary_keywords and
+            (self._image and self._image[:9].upper() != 'HIERARCH ' and
+             self._image.find('=') != 8)):
+            errs.append(self.run_option(
+                option,
+                err_text='Card {!r} is not FITS standard (equal sign not '
+                         'at column 8).'.format(self.keyword),
+                fix_text=fix_text,
+                fix=self._fix_value))
+
+        # verify the key, it is never fixable
+        # always fix silently the case where "=" is before column 9,
+        # since there is no way to communicate back to the _keys.
+        if ((self._image and self._image[:8].upper() == 'HIERARCH') or
+                self._hierarch):
+            pass
+        else:
+            if self._image:
+                # PyFITS will auto-uppercase any standard keyword, so lowercase
+                # keywords can only occur if they came from the wild
+                keyword = self._split()[0]
+                if keyword != keyword.upper():
+                    # Keyword should be uppercase unless it's a HIERARCH card
+                    errs.append(self.run_option(
+                        option,
+                        err_text='Card keyword {!r} is not upper case.'.format(
+                                  keyword),
+                        fix_text=fix_text,
+                        fix=self._fix_keyword))
+
+            keyword = self.keyword
+            if self.field_specifier:
+                keyword = keyword.split('.', 1)[0]
+
+            if not self._keywd_FSC_RE.match(keyword):
+                errs.append(self.run_option(
+                    option,
+                    err_text='Illegal keyword name {!r}'.format(keyword),
+                    fixable=False))
+
+        # verify the value, it may be fixable
+        keyword, valuecomment = self._split()
+        if self.keyword in self._commentary_keywords:
+            # For commentary keywords all that needs to be ensured is that it
+            # contains only printable ASCII characters
+            if not self._ascii_text_re.match(valuecomment):
+                errs.append(self.run_option(
+                    option,
+                    err_text='Unprintable string {!r}; commentary cards may '
+                             'only contain printable ASCII characters'.format(
+                             valuecomment),
+                    fixable=False))
+        else:
+            m = self._value_FSC_RE.match(valuecomment)
+            if not m:
+                errs.append(self.run_option(
+                    option,
+                    err_text='Card {!r} is not FITS standard (invalid value '
+                             'string: {!r}).'.format(self.keyword, valuecomment),
+                    fix_text=fix_text,
+                    fix=self._fix_value))
+
+        # verify the comment (string), it is never fixable
+        m = self._value_NFSC_RE.match(valuecomment)
+        if m is not None:
+            comment = m.group('comm')
+            if comment is not None:
+                if not self._ascii_text_re.match(comment):
+                    errs.append(self.run_option(
+                        option,
+                        err_text=('Unprintable string {!r}; header comments '
+                                  'may only contain printable ASCII '
+                                  'characters'.format(comment)),
+                        fixable=False))
+
+        return errs
+
+    def _itersubcards(self):
+        """
+        If the card image is greater than 80 characters, it should consist of a
+        normal card followed by one or more CONTINUE card.  This method returns
+        the subcards that make up this logical card.
+        """
+
+        ncards = len(self._image) // Card.length
+
+        for idx in range(0, Card.length * ncards, Card.length):
+            card = Card.fromstring(self._image[idx:idx + Card.length])
+            if idx > 0 and card.keyword.upper() != 'CONTINUE':
+                raise VerifyError(
+                        'Long card images must have CONTINUE cards after '
+                        'the first card.')
+
+            if not isinstance(card.value, str):
+                raise VerifyError('CONTINUE cards must have string values.')
+
+            yield card
+
+
+def _int_or_float(s):
+    """
+    Converts an a string to an int if possible, or to a float.
+
+    If the string is neither a string or a float a value error is raised.
+    """
+
+    if isinstance(s, float):
+        # Already a float so just pass through
+        return s
+
+    try:
+        return int(s)
+    except (ValueError, TypeError):
+        try:
+            return float(s)
+        except (ValueError, TypeError) as e:
+            raise ValueError(str(e))
+
+
+def _format_value(value):
+    """
+    Converts a card value to its appropriate string representation as
+    defined by the FITS format.
+    """
+
+    # string value should occupies at least 8 columns, unless it is
+    # a null string
+    if isinstance(value, str):
+        if value == '':
+            return "''"
+        else:
+            exp_val_str = value.replace("'", "''")
+            val_str = "'{:8}'".format(exp_val_str)
+            return '{:20}'.format(val_str)
+
+    # must be before int checking since bool is also int
+    elif isinstance(value, (bool, np.bool_)):
+        return '{:>20}'.format(repr(value)[0])  # T or F
+
+    elif _is_int(value):
+        return '{:>20d}'.format(value)
+
+    elif isinstance(value, (float, np.floating)):
+        return '{:>20}'.format(_format_float(value))
+
+    elif isinstance(value, (complex, np.complexfloating)):
+        val_str = '({}, {})'.format(_format_float(value.real),
+                                    _format_float(value.imag))
+        return '{:>20}'.format(val_str)
+
+    elif isinstance(value, Undefined):
+        return ''
+    else:
+        return ''
+
+
+def _format_float(value):
+    """Format a floating number to make sure it gets the decimal point."""
+
+    value_str = '{:.16G}'.format(value)
+    if '.' not in value_str and 'E' not in value_str:
+        value_str += '.0'
+    elif 'E' in value_str:
+        # On some Windows builds of Python (and possibly other platforms?) the
+        # exponent is zero-padded out to, it seems, three digits.  Normalize
+        # the format to pad only to two digits.
+        significand, exponent = value_str.split('E')
+        if exponent[0] in ('+', '-'):
+            sign = exponent[0]
+            exponent = exponent[1:]
+        else:
+            sign = ''
+        value_str = '{}E{}{:02d}'.format(significand, sign, int(exponent))
+
+    # Limit the value string to at most 20 characters.
+    str_len = len(value_str)
+
+    if str_len > 20:
+        idx = value_str.find('E')
+
+        if idx < 0:
+            value_str = value_str[:20]
+        else:
+            value_str = value_str[:20 - (str_len - idx)] + value_str[idx:]
+
+    return value_str
+
+
+def _pad(input):
+    """Pad blank space to the input string to be multiple of 80."""
+
+    _len = len(input)
+    if _len == Card.length:
+        return input
+    elif _len > Card.length:
+        strlen = _len % Card.length
+        if strlen == 0:
+            return input
+        else:
+            return input + ' ' * (Card.length - strlen)
+
+    # minimum length is 80
+    else:
+        strlen = _len % Card.length
+        return input + ' ' * (Card.length - strlen)

testbed/astropy__astropy/astropy/io/fits/column.py

@@ -0,0 +1,2615 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import copy
+import operator
+import re
+import sys
+import warnings
+import weakref
+import numbers
+
+from functools import reduce
+from collections import OrderedDict
+from contextlib import suppress
+
+import numpy as np
+from numpy import char as chararray
+
+from .card import Card, CARD_LENGTH
+from .util import (pairwise, _is_int, _convert_array, encode_ascii, cmp,
+                   NotifierMixin)
+from .verify import VerifyError, VerifyWarning
+
+from astropy.utils import lazyproperty, isiterable, indent
+from astropy.utils.exceptions import AstropyUserWarning
+
+__all__ = ['Column', 'ColDefs', 'Delayed']
+
+
+# mapping from TFORM data type to numpy data type (code)
+# L: Logical (Boolean)
+# B: Unsigned Byte
+# I: 16-bit Integer
+# J: 32-bit Integer
+# K: 64-bit Integer
+# E: Single-precision Floating Point
+# D: Double-precision Floating Point
+# C: Single-precision Complex
+# M: Double-precision Complex
+# A: Character
+FITS2NUMPY = {'L': 'i1', 'B': 'u1', 'I': 'i2', 'J': 'i4', 'K': 'i8', 'E': 'f4',
+              'D': 'f8', 'C': 'c8', 'M': 'c16', 'A': 'a'}
+
+# the inverse dictionary of the above
+NUMPY2FITS = {val: key for key, val in FITS2NUMPY.items()}
+# Normally booleans are represented as ints in Astropy, but if passed in a numpy
+# boolean array, that should be supported
+NUMPY2FITS['b1'] = 'L'
+# Add unsigned types, which will be stored as signed ints with a TZERO card.
+NUMPY2FITS['u2'] = 'I'
+NUMPY2FITS['u4'] = 'J'
+NUMPY2FITS['u8'] = 'K'
+# Add half precision floating point numbers which will be up-converted to
+# single precision.
+NUMPY2FITS['f2'] = 'E'
+
+# This is the order in which values are converted to FITS types
+# Note that only double precision floating point/complex are supported
+FORMATORDER = ['L', 'B', 'I', 'J', 'K', 'D', 'M', 'A']
+
+# Convert single precision floating point/complex to double precision.
+FITSUPCONVERTERS = {'E': 'D', 'C': 'M'}
+
+# mapping from ASCII table TFORM data type to numpy data type
+# A: Character
+# I: Integer (32-bit)
+# J: Integer (64-bit; non-standard)
+# F: Float (64-bit; fixed decimal notation)
+# E: Float (64-bit; exponential notation)
+# D: Float (64-bit; exponential notation, always 64-bit by convention)
+ASCII2NUMPY = {'A': 'a', 'I': 'i4', 'J': 'i8', 'F': 'f8', 'E': 'f8', 'D': 'f8'}
+
+# Maps FITS ASCII column format codes to the appropriate Python string
+# formatting codes for that type.
+ASCII2STR = {'A': '', 'I': 'd', 'J': 'd', 'F': 'f', 'E': 'E', 'D': 'E'}
+
+# For each ASCII table format code, provides a default width (and decimal
+# precision) for when one isn't given explicitly in the column format
+ASCII_DEFAULT_WIDTHS = {'A': (1, 0), 'I': (10, 0), 'J': (15, 0),
+                        'E': (15, 7), 'F': (16, 7), 'D': (25, 17)}
+
+# TDISPn for both ASCII and Binary tables
+TDISP_RE_DICT = {}
+TDISP_RE_DICT['F'] = re.compile(r'(?:(?P<formatc>[F])(?:(?P<width>[0-9]+)\.{1}'
+                                r'(?P<precision>[0-9])+)+)|')
+TDISP_RE_DICT['A'] = TDISP_RE_DICT['L'] = \
+    re.compile(r'(?:(?P<formatc>[AL])(?P<width>[0-9]+)+)|')
+TDISP_RE_DICT['I'] = TDISP_RE_DICT['B'] = \
+    TDISP_RE_DICT['O'] = TDISP_RE_DICT['Z'] =  \
+    re.compile(r'(?:(?P<formatc>[IBOZ])(?:(?P<width>[0-9]+)'
+               r'(?:\.{0,1}(?P<precision>[0-9]+))?))|')
+TDISP_RE_DICT['E'] = TDISP_RE_DICT['G'] = \
+    TDISP_RE_DICT['D'] = \
+    re.compile(r'(?:(?P<formatc>[EGD])(?:(?P<width>[0-9]+)\.'
+               r'(?P<precision>[0-9]+))+)'
+               r'(?:E{0,1}(?P<exponential>[0-9]+)?)|')
+TDISP_RE_DICT['EN'] = TDISP_RE_DICT['ES'] = \
+    re.compile(r'(?:(?P<formatc>E[NS])(?:(?P<width>[0-9]+)\.{1}'
+               r'(?P<precision>[0-9])+)+)')
+
+# mapping from TDISP format to python format
+# A: Character
+# L: Logical (Boolean)
+# I: 16-bit Integer
+#    Can't predefine zero padding and space padding before hand without
+#    knowing the value being formatted, so grabbing precision and using that
+#    to zero pad, ignoring width. Same with B, O, and Z
+# B: Binary Integer
+# O: Octal Integer
+# Z: Hexadecimal Integer
+# F: Float (64-bit; fixed decimal notation)
+# EN: Float (engineering fortran format, exponential multiple of thee
+# ES: Float (scientific, same as EN but non-zero leading digit
+# E: Float, exponential notation
+#    Can't get exponential restriction to work without knowing value
+#    before hand, so just using width and precision, same with D, G, EN, and
+#    ES formats
+# D: Double-precision Floating Point with exponential
+#    (E but for double precision)
+# G: Double-precision Floating Point, may or may not show exponent
+TDISP_FMT_DICT = {'I' : '{{:{width}d}}',
+                  'B' : '{{:{width}b}}',
+                  'O' : '{{:{width}o}}',
+                  'Z' : '{{:{width}x}}',
+                  'F' : '{{:{width}.{precision}f}}',
+                  'G' : '{{:{width}.{precision}g}}'}
+TDISP_FMT_DICT['A'] = TDISP_FMT_DICT['L'] = '{{:>{width}}}'
+TDISP_FMT_DICT['E'] = TDISP_FMT_DICT['D'] =  \
+    TDISP_FMT_DICT['EN'] = TDISP_FMT_DICT['ES'] ='{{:{width}.{precision}e}}'
+
+# tuple of column/field definition common names and keyword names, make
+# sure to preserve the one-to-one correspondence when updating the list(s).
+# Use lists, instead of dictionaries so the names can be displayed in a
+# preferred order.
+KEYWORD_NAMES = ('TTYPE', 'TFORM', 'TUNIT', 'TNULL', 'TSCAL', 'TZERO',
+                 'TDISP', 'TBCOL', 'TDIM', 'TCTYP', 'TCUNI', 'TCRPX',
+                 'TCRVL', 'TCDLT', 'TRPOS')
+KEYWORD_ATTRIBUTES = ('name', 'format', 'unit', 'null', 'bscale', 'bzero',
+                      'disp', 'start', 'dim', 'coord_type', 'coord_unit',
+                      'coord_ref_point', 'coord_ref_value', 'coord_inc',
+                      'time_ref_pos')
+"""This is a list of the attributes that can be set on `Column` objects."""
+
+
+KEYWORD_TO_ATTRIBUTE = OrderedDict(zip(KEYWORD_NAMES, KEYWORD_ATTRIBUTES))
+
+ATTRIBUTE_TO_KEYWORD = OrderedDict(zip(KEYWORD_ATTRIBUTES, KEYWORD_NAMES))
+
+
+# TODO: Define a list of default comments to associate with each table keyword
+
+# TFORMn regular expression
+TFORMAT_RE = re.compile(r'(?P<repeat>^[0-9]*)(?P<format>[LXBIJKAEDCMPQ])'
+                        r'(?P<option>[!-~]*)', re.I)
+
+# TFORMn for ASCII tables; two different versions depending on whether
+# the format is floating-point or not; allows empty values for width
+# in which case defaults are used
+TFORMAT_ASCII_RE = re.compile(r'(?:(?P<format>[AIJ])(?P<width>[0-9]+)?)|'
+                              r'(?:(?P<formatf>[FED])'
+                              r'(?:(?P<widthf>[0-9]+)\.'
+                              r'(?P<precision>[0-9]+))?)')
+
+TTYPE_RE = re.compile(r'[0-9a-zA-Z_]+')
+"""
+Regular expression for valid table column names.  See FITS Standard v3.0 section
+7.2.2.
+"""
+
+# table definition keyword regular expression
+TDEF_RE = re.compile(r'(?P<label>^T[A-Z]*)(?P<num>[1-9][0-9 ]*$)')
+
+# table dimension keyword regular expression (fairly flexible with whitespace)
+TDIM_RE = re.compile(r'\(\s*(?P<dims>(?:\d+,\s*)+\s*\d+)\s*\)\s*')
+
+# value for ASCII table cell with value = TNULL
+# this can be reset by user.
+ASCIITNULL = 0
+
+# The default placeholder to use for NULL values in ASCII tables when
+# converting from binary to ASCII tables
+DEFAULT_ASCII_TNULL = '---'
+
+
+class Delayed:
+    """Delayed file-reading data."""
+
+    def __init__(self, hdu=None, field=None):
+        self.hdu = weakref.proxy(hdu)
+        self.field = field
+
+    def __getitem__(self, key):
+        # This forces the data for the HDU to be read, which will replace
+        # the corresponding Delayed objects in the Tables Columns to be
+        # transformed into ndarrays.  It will also return the value of the
+        # requested data element.
+        return self.hdu.data[key][self.field]
+
+
+class _BaseColumnFormat(str):
+    """
+    Base class for binary table column formats (just called _ColumnFormat)
+    and ASCII table column formats (_AsciiColumnFormat).
+    """
+
+    def __eq__(self, other):
+        if not other:
+            return False
+
+        if isinstance(other, str):
+            if not isinstance(other, self.__class__):
+                try:
+                    other = self.__class__(other)
+                except ValueError:
+                    return False
+        else:
+            return False
+
+        return self.canonical == other.canonical
+
+    def __hash__(self):
+        return hash(self.canonical)
+
+    @lazyproperty
+    def dtype(self):
+        """
+        The Numpy dtype object created from the format's associated recformat.
+        """
+
+        return np.dtype(self.recformat)
+
+    @classmethod
+    def from_column_format(cls, format):
+        """Creates a column format object from another column format object
+        regardless of their type.
+
+        That is, this can convert a _ColumnFormat to an _AsciiColumnFormat
+        or vice versa at least in cases where a direct translation is possible.
+        """
+
+        return cls.from_recformat(format.recformat)
+
+
+class _ColumnFormat(_BaseColumnFormat):
+    """
+    Represents a FITS binary table column format.
+
+    This is an enhancement over using a normal string for the format, since the
+    repeat count, format code, and option are available as separate attributes,
+    and smart comparison is used.  For example 1J == J.
+    """
+
+    def __new__(cls, format):
+        self = super().__new__(cls, format)
+        self.repeat, self.format, self.option = _parse_tformat(format)
+        self.format = self.format.upper()
+        if self.format in ('P', 'Q'):
+            # TODO: There should be a generic factory that returns either
+            # _FormatP or _FormatQ as appropriate for a given TFORMn
+            if self.format == 'P':
+                recformat = _FormatP.from_tform(format)
+            else:
+                recformat = _FormatQ.from_tform(format)
+            # Format of variable length arrays
+            self.p_format = recformat.format
+        else:
+            self.p_format = None
+        return self
+
+    @classmethod
+    def from_recformat(cls, recformat):
+        """Creates a column format from a Numpy record dtype format."""
+
+        return cls(_convert_format(recformat, reverse=True))
+
+    @lazyproperty
+    def recformat(self):
+        """Returns the equivalent Numpy record format string."""
+
+        return _convert_format(self)
+
+    @lazyproperty
+    def canonical(self):
+        """
+        Returns a 'canonical' string representation of this format.
+
+        This is in the proper form of rTa where T is the single character data
+        type code, a is the optional part, and r is the repeat.  If repeat == 1
+        (the default) it is left out of this representation.
+        """
+
+        if self.repeat == 1:
+            repeat = ''
+        else:
+            repeat = str(self.repeat)
+
+        return '{}{}{}'.format(repeat, self.format, self.option)
+
+
+class _AsciiColumnFormat(_BaseColumnFormat):
+    """Similar to _ColumnFormat but specifically for columns in ASCII tables.
+
+    The formats of ASCII table columns and binary table columns are inherently
+    incompatible in FITS.  They don't support the same ranges and types of
+    values, and even reuse format codes in subtly different ways.  For example
+    the format code 'Iw' in ASCII columns refers to any integer whose string
+    representation is at most w characters wide, so 'I' can represent
+    effectively any integer that will fit in a FITS columns.  Whereas for
+    binary tables 'I' very explicitly refers to a 16-bit signed integer.
+
+    Conversions between the two column formats can be performed using the
+    ``to/from_binary`` methods on this class, or the ``to/from_ascii``
+    methods on the `_ColumnFormat` class.  But again, not all conversions are
+    possible and may result in a `ValueError`.
+    """
+
+    def __new__(cls, format, strict=False):
+        self = super().__new__(cls, format)
+        self.format, self.width, self.precision = \
+            _parse_ascii_tformat(format, strict)
+
+        # This is to support handling logical (boolean) data from binary tables
+        # in an ASCII table
+        self._pseudo_logical = False
+        return self
+
+    @classmethod
+    def from_column_format(cls, format):
+        inst = cls.from_recformat(format.recformat)
+        # Hack
+        if format.format == 'L':
+            inst._pseudo_logical = True
+        return inst
+
+    @classmethod
+    def from_recformat(cls, recformat):
+        """Creates a column format from a Numpy record dtype format."""
+
+        return cls(_convert_ascii_format(recformat, reverse=True))
+
+    @lazyproperty
+    def recformat(self):
+        """Returns the equivalent Numpy record format string."""
+
+        return _convert_ascii_format(self)
+
+    @lazyproperty
+    def canonical(self):
+        """
+        Returns a 'canonical' string representation of this format.
+
+        This is in the proper form of Tw.d where T is the single character data
+        type code, w is the width in characters for this field, and d is the
+        number of digits after the decimal place (for format codes 'E', 'F',
+        and 'D' only).
+        """
+
+        if self.format in ('E', 'F', 'D'):
+            return '{}{}.{}'.format(self.format, self.width, self.precision)
+
+        return '{}{}'.format(self.format, self.width)
+
+
+class _FormatX(str):
+    """For X format in binary tables."""
+
+    def __new__(cls, repeat=1):
+        nbytes = ((repeat - 1) // 8) + 1
+        # use an array, even if it is only ONE u1 (i.e. use tuple always)
+        obj = super().__new__(cls, repr((nbytes,)) + 'u1')
+        obj.repeat = repeat
+        return obj
+
+    def __getnewargs__(self):
+        return (self.repeat,)
+
+    @property
+    def tform(self):
+        return '{}X'.format(self.repeat)
+
+
+# TODO: Table column formats need to be verified upon first reading the file;
+# as it is, an invalid P format will raise a VerifyError from some deep,
+# unexpected place
+class _FormatP(str):
+    """For P format in variable length table."""
+
+    # As far as I can tell from my reading of the FITS standard, a type code is
+    # *required* for P and Q formats; there is no default
+    _format_re_template = (r'(?P<repeat>\d+)?{}(?P<dtype>[LXBIJKAEDCM])'
+                           r'(?:\((?P<max>\d*)\))?')
+    _format_code = 'P'
+    _format_re = re.compile(_format_re_template.format(_format_code))
+    _descriptor_format = '2i4'
+
+    def __new__(cls, dtype, repeat=None, max=None):
+        obj = super().__new__(cls, cls._descriptor_format)
+        obj.format = NUMPY2FITS[dtype]
+        obj.dtype = dtype
+        obj.repeat = repeat
+        obj.max = max
+        return obj
+
+    def __getnewargs__(self):
+        return (self.dtype, self.repeat, self.max)
+
+    @classmethod
+    def from_tform(cls, format):
+        m = cls._format_re.match(format)
+        if not m or m.group('dtype') not in FITS2NUMPY:
+            raise VerifyError('Invalid column format: {}'.format(format))
+        repeat = m.group('repeat')
+        array_dtype = m.group('dtype')
+        max = m.group('max')
+        if not max:
+            max = None
+        return cls(FITS2NUMPY[array_dtype], repeat=repeat, max=max)
+
+    @property
+    def tform(self):
+        repeat = '' if self.repeat is None else self.repeat
+        max = '' if self.max is None else self.max
+        return '{}{}{}({})'.format(repeat, self._format_code, self.format, max)
+
+
+class _FormatQ(_FormatP):
+    """Carries type description of the Q format for variable length arrays.
+
+    The Q format is like the P format but uses 64-bit integers in the array
+    descriptors, allowing for heaps stored beyond 2GB into a file.
+    """
+
+    _format_code = 'Q'
+    _format_re = re.compile(_FormatP._format_re_template.format(_format_code))
+    _descriptor_format = '2i8'
+
+
+class ColumnAttribute:
+    """
+    Descriptor for attributes of `Column` that are associated with keywords
+    in the FITS header and describe properties of the column as specified in
+    the FITS standard.
+
+    Each `ColumnAttribute` may have a ``validator`` method defined on it.
+    This validates values set on this attribute to ensure that they meet the
+    FITS standard.  Invalid values will raise a warning and will not be used in
+    formatting the column.  The validator should take two arguments--the
+    `Column` it is being assigned to, and the new value for the attribute, and
+    it must raise an `AssertionError` if the value is invalid.
+
+    The `ColumnAttribute` itself is a decorator that can be used to define the
+    ``validator`` for each column attribute.  For example::
+
+        @ColumnAttribute('TTYPE')
+        def name(col, name):
+            if not isinstance(name, str):
+                raise AssertionError
+
+    The actual object returned by this decorator is the `ColumnAttribute`
+    instance though, not the ``name`` function.  As such ``name`` is not a
+    method of the class it is defined in.
+
+    The setter for `ColumnAttribute` also updates the header of any table
+    HDU this column is attached to in order to reflect the change.  The
+    ``validator`` should ensure that the value is valid for inclusion in a FITS
+    header.
+    """
+
+    def __init__(self, keyword):
+        self._keyword = keyword
+        self._validator = None
+
+        # The name of the attribute associated with this keyword is currently
+        # determined from the KEYWORD_NAMES/ATTRIBUTES lists.  This could be
+        # make more flexible in the future, for example, to support custom
+        # column attributes.
+        self._attr = '_' + KEYWORD_TO_ATTRIBUTE[self._keyword]
+
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            return self
+        else:
+            return getattr(obj, self._attr)
+
+    def __set__(self, obj, value):
+        if self._validator is not None:
+            self._validator(obj, value)
+
+        old_value = getattr(obj, self._attr, None)
+        setattr(obj, self._attr, value)
+        obj._notify('column_attribute_changed', obj, self._attr[1:], old_value,
+                    value)
+
+    def __call__(self, func):
+        """
+        Set the validator for this column attribute.
+
+        Returns ``self`` so that this can be used as a decorator, as described
+        in the docs for this class.
+        """
+
+        self._validator = func
+
+        return self
+
+    def __repr__(self):
+        return "{0}('{1}')".format(self.__class__.__name__, self._keyword)
+
+
+class Column(NotifierMixin):
+    """
+    Class which contains the definition of one column, e.g.  ``ttype``,
+    ``tform``, etc. and the array containing values for the column.
+    """
+
+    def __init__(self, name=None, format=None, unit=None, null=None,
+                 bscale=None, bzero=None, disp=None, start=None, dim=None,
+                 array=None, ascii=None, coord_type=None, coord_unit=None,
+                 coord_ref_point=None, coord_ref_value=None, coord_inc=None,
+                 time_ref_pos=None):
+        """
+        Construct a `Column` by specifying attributes.  All attributes
+        except ``format`` can be optional; see :ref:`column_creation` and
+        :ref:`creating_ascii_table` for more information regarding
+        ``TFORM`` keyword.
+
+        Parameters
+        ----------
+        name : str, optional
+            column name, corresponding to ``TTYPE`` keyword
+
+        format : str
+            column format, corresponding to ``TFORM`` keyword
+
+        unit : str, optional
+            column unit, corresponding to ``TUNIT`` keyword
+
+        null : str, optional
+            null value, corresponding to ``TNULL`` keyword
+
+        bscale : int-like, optional
+            bscale value, corresponding to ``TSCAL`` keyword
+
+        bzero : int-like, optional
+            bzero value, corresponding to ``TZERO`` keyword
+
+        disp : str, optional
+            display format, corresponding to ``TDISP`` keyword
+
+        start : int, optional
+            column starting position (ASCII table only), corresponding
+            to ``TBCOL`` keyword
+
+        dim : str, optional
+            column dimension corresponding to ``TDIM`` keyword
+
+        array : iterable, optional
+            a `list`, `numpy.ndarray` (or other iterable that can be used to
+            initialize an ndarray) providing initial data for this column.
+            The array will be automatically converted, if possible, to the data
+            format of the column.  In the case were non-trivial ``bscale``
+            and/or ``bzero`` arguments are given, the values in the array must
+            be the *physical* values--that is, the values of column as if the
+            scaling has already been applied (the array stored on the column
+            object will then be converted back to its storage values).
+
+        ascii : bool, optional
+            set `True` if this describes a column for an ASCII table; this
+            may be required to disambiguate the column format
+
+        coord_type : str, optional
+            coordinate/axis type corresponding to ``TCTYP`` keyword
+
+        coord_unit : str, optional
+            coordinate/axis unit corresponding to ``TCUNI`` keyword
+
+        coord_ref_point : int-like, optional
+            pixel coordinate of the reference point corresponding to ``TCRPX``
+            keyword
+
+        coord_ref_value : int-like, optional
+            coordinate value at reference point corresponding to ``TCRVL``
+            keyword
+
+        coord_inc : int-like, optional
+            coordinate increment at reference point corresponding to ``TCDLT``
+            keyword
+
+        time_ref_pos : str, optional
+            reference position for a time coordinate column corresponding to
+            ``TRPOS`` keyword
+        """
+
+        if format is None:
+            raise ValueError('Must specify format to construct Column.')
+
+        # any of the input argument (except array) can be a Card or just
+        # a number/string
+        kwargs = {'ascii': ascii}
+        for attr in KEYWORD_ATTRIBUTES:
+            value = locals()[attr]  # get the argument's value
+
+            if isinstance(value, Card):
+                value = value.value
+
+            kwargs[attr] = value
+
+        valid_kwargs, invalid_kwargs = self._verify_keywords(**kwargs)
+
+        if invalid_kwargs:
+            msg = ['The following keyword arguments to Column were invalid:']
+
+            for val in invalid_kwargs.values():
+                msg.append(indent(val[1]))
+
+            raise VerifyError('\n'.join(msg))
+
+        for attr in KEYWORD_ATTRIBUTES:
+            setattr(self, attr, valid_kwargs.get(attr))
+
+        # TODO: Try to eliminate the following two special cases
+        # for recformat and dim:
+        # This is not actually stored as an attribute on columns for some
+        # reason
+        recformat = valid_kwargs['recformat']
+
+        # The 'dim' keyword's original value is stored in self.dim, while
+        # *only* the tuple form is stored in self._dims.
+        self._dims = self.dim
+        self.dim = dim
+
+        # Awful hack to use for now to keep track of whether the column holds
+        # pseudo-unsigned int data
+        self._pseudo_unsigned_ints = False
+
+        # if the column data is not ndarray, make it to be one, i.e.
+        # input arrays can be just list or tuple, not required to be ndarray
+        # does not include Object array because there is no guarantee
+        # the elements in the object array are consistent.
+        if not isinstance(array,
+                          (np.ndarray, chararray.chararray, Delayed)):
+            try:  # try to convert to a ndarray first
+                if array is not None:
+                    array = np.array(array)
+            except Exception:
+                try:  # then try to convert it to a strings array
+                    itemsize = int(recformat[1:])
+                    array = chararray.array(array, itemsize=itemsize)
+                except ValueError:
+                    # then try variable length array
+                    # Note: This includes _FormatQ by inheritance
+                    if isinstance(recformat, _FormatP):
+                        array = _VLF(array, dtype=recformat.dtype)
+                    else:
+                        raise ValueError('Data is inconsistent with the '
+                                         'format `{}`.'.format(format))
+
+        array = self._convert_to_valid_data_type(array)
+
+        # We have required (through documentation) that arrays passed in to
+        # this constructor are already in their physical values, so we make
+        # note of that here
+        if isinstance(array, np.ndarray):
+            self._physical_values = True
+        else:
+            self._physical_values = False
+
+        self._parent_fits_rec = None
+        self.array = array
+
+    def __repr__(self):
+        text = ''
+        for attr in KEYWORD_ATTRIBUTES:
+            value = getattr(self, attr)
+            if value is not None:
+                text += attr + ' = ' + repr(value) + '; '
+        return text[:-2]
+
+    def __eq__(self, other):
+        """
+        Two columns are equal if their name and format are the same.  Other
+        attributes aren't taken into account at this time.
+        """
+
+        # According to the FITS standard column names must be case-insensitive
+        a = (self.name.lower(), self.format)
+        b = (other.name.lower(), other.format)
+        return a == b
+
+    def __hash__(self):
+        """
+        Like __eq__, the hash of a column should be based on the unique column
+        name and format, and be case-insensitive with respect to the column
+        name.
+        """
+
+        return hash((self.name.lower(), self.format))
+
+    @property
+    def array(self):
+        """
+        The Numpy `~numpy.ndarray` associated with this `Column`.
+
+        If the column was instantiated with an array passed to the ``array``
+        argument, this will return that array.  However, if the column is
+        later added to a table, such as via `BinTableHDU.from_columns` as
+        is typically the case, this attribute will be updated to reference
+        the associated field in the table, which may no longer be the same
+        array.
+        """
+
+        # Ideally the .array attribute never would have existed in the first
+        # place, or would have been internal-only.  This is a legacy of the
+        # older design from Astropy that needs to have continued support, for
+        # now.
+
+        # One of the main problems with this design was that it created a
+        # reference cycle.  When the .array attribute was updated after
+        # creating a FITS_rec from the column (as explained in the docstring) a
+        # reference cycle was created.  This is because the code in BinTableHDU
+        # (and a few other places) does essentially the following:
+        #
+        # data._coldefs = columns  # The ColDefs object holding this Column
+        # for col in columns:
+        #     col.array = data.field(col.name)
+        #
+        # This way each columns .array attribute now points to the field in the
+        # table data.  It's actually a pretty confusing interface (since it
+        # replaces the array originally pointed to by .array), but it's the way
+        # things have been for a long, long time.
+        #
+        # However, this results, in *many* cases, in a reference cycle.
+        # Because the array returned by data.field(col.name), while sometimes
+        # an array that owns its own data, is usually like a slice of the
+        # original data.  It has the original FITS_rec as the array .base.
+        # This results in the following reference cycle (for the n-th column):
+        #
+        #    data -> data._coldefs -> data._coldefs[n] ->
+        #     data._coldefs[n].array -> data._coldefs[n].array.base -> data
+        #
+        # Because ndarray objects do not handled by Python's garbage collector
+        # the reference cycle cannot be broken.  Therefore the FITS_rec's
+        # refcount never goes to zero, its __del__ is never called, and its
+        # memory is never freed.  This didn't occur in *all* cases, but it did
+        # occur in many cases.
+        #
+        # To get around this, Column.array is no longer a simple attribute
+        # like it was previously.  Now each Column has a ._parent_fits_rec
+        # attribute which is a weakref to a FITS_rec object.  Code that
+        # previously assigned each col.array to field in a FITS_rec (as in
+        # the example a few paragraphs above) is still used, however now
+        # array.setter checks if a reference cycle will be created.  And if
+        # so, instead of saving directly to the Column's __dict__, it creates
+        # the ._prent_fits_rec weakref, and all lookups of the column's .array
+        # go through that instead.
+        #
+        # This alone does not fully solve the problem.  Because
+        # _parent_fits_rec is a weakref, if the user ever holds a reference to
+        # the Column, but deletes all references to the underlying FITS_rec,
+        # the .array attribute would suddenly start returning None instead of
+        # the array data.  This problem is resolved on FITS_rec's end.  See the
+        # note in the FITS_rec._coldefs property for the rest of the story.
+
+        # If the Columns's array is not a reference to an existing FITS_rec,
+        # then it is just stored in self.__dict__; otherwise check the
+        # _parent_fits_rec reference if it 's still available.
+        if 'array' in self.__dict__:
+            return self.__dict__['array']
+        elif self._parent_fits_rec is not None:
+            parent = self._parent_fits_rec()
+            if parent is not None:
+                return parent[self.name]
+        else:
+            return None
+
+    @array.setter
+    def array(self, array):
+        # The following looks over the bases of the given array to check if it
+        # has a ._coldefs attribute (i.e. is a FITS_rec) and that that _coldefs
+        # contains this Column itself, and would create a reference cycle if we
+        # stored the array directly in self.__dict__.
+        # In this case it instead sets up the _parent_fits_rec weakref to the
+        # underlying FITS_rec, so that array.getter can return arrays through
+        # self._parent_fits_rec().field(self.name), rather than storing a
+        # hard reference to the field like it used to.
+        base = array
+        while True:
+            if (hasattr(base, '_coldefs') and
+                    isinstance(base._coldefs, ColDefs)):
+                for col in base._coldefs:
+                    if col is self and self._parent_fits_rec is None:
+                        self._parent_fits_rec = weakref.ref(base)
+
+                        # Just in case the user already set .array to their own
+                        # array.
+                        if 'array' in self.__dict__:
+                            del self.__dict__['array']
+                        return
+
+            if getattr(base, 'base', None) is not None:
+                base = base.base
+            else:
+                break
+
+        self.__dict__['array'] = array
+
+    @array.deleter
+    def array(self):
+        try:
+            del self.__dict__['array']
+        except KeyError:
+            pass
+
+        self._parent_fits_rec = None
+
+    @ColumnAttribute('TTYPE')
+    def name(col, name):
+        if name is None:
+            # Allow None to indicate deleting the name, or to just indicate an
+            # unspecified name (when creating a new Column).
+            return
+
+        # Check that the name meets the recommended standard--other column
+        # names are *allowed*, but will be discouraged
+        if isinstance(name, str) and not TTYPE_RE.match(name):
+            warnings.warn(
+                'It is strongly recommended that column names contain only '
+                'upper and lower-case ASCII letters, digits, or underscores '
+                'for maximum compatibility with other software '
+                '(got {0!r}).'.format(name), VerifyWarning)
+
+        # This ensures that the new name can fit into a single FITS card
+        # without any special extension like CONTINUE cards or the like.
+        if (not isinstance(name, str)
+                or len(str(Card('TTYPE', name))) != CARD_LENGTH):
+            raise AssertionError(
+                'Column name must be a string able to fit in a single '
+                'FITS card--typically this means a maximum of 68 '
+                'characters, though it may be fewer if the string '
+                'contains special characters like quotes.')
+
+    @ColumnAttribute('TCTYP')
+    def coord_type(col, coord_type):
+        if coord_type is None:
+            return
+
+        if (not isinstance(coord_type, str)
+                or len(coord_type) > 8):
+            raise AssertionError(
+                'Coordinate/axis type must be a string of atmost 8 '
+                'characters.')
+
+    @ColumnAttribute('TCUNI')
+    def coord_unit(col, coord_unit):
+        if (coord_unit is not None
+                and not isinstance(coord_unit, str)):
+            raise AssertionError(
+                'Coordinate/axis unit must be a string.')
+
+    @ColumnAttribute('TCRPX')
+    def coord_ref_point(col, coord_ref_point):
+        if (coord_ref_point is not None
+                and not isinstance(coord_ref_point, numbers.Real)):
+            raise AssertionError(
+                'Pixel coordinate of the reference point must be '
+                'real floating type.')
+
+    @ColumnAttribute('TCRVL')
+    def coord_ref_value(col, coord_ref_value):
+        if (coord_ref_value is not None
+                and not isinstance(coord_ref_value, numbers.Real)):
+            raise AssertionError(
+                'Coordinate value at reference point must be real '
+                'floating type.')
+
+    @ColumnAttribute('TCDLT')
+    def coord_inc(col, coord_inc):
+        if (coord_inc is not None
+                and not isinstance(coord_inc, numbers.Real)):
+            raise AssertionError(
+                'Coordinate increment must be real floating type.')
+
+    @ColumnAttribute('TRPOS')
+    def time_ref_pos(col, time_ref_pos):
+        if (time_ref_pos is not None
+                and not isinstance(time_ref_pos, str)):
+            raise AssertionError(
+                'Time reference position must be a string.')
+
+    format = ColumnAttribute('TFORM')
+    unit = ColumnAttribute('TUNIT')
+    null = ColumnAttribute('TNULL')
+    bscale = ColumnAttribute('TSCAL')
+    bzero = ColumnAttribute('TZERO')
+    disp = ColumnAttribute('TDISP')
+    start = ColumnAttribute('TBCOL')
+    dim = ColumnAttribute('TDIM')
+
+    @lazyproperty
+    def ascii(self):
+        """Whether this `Column` represents a column in an ASCII table."""
+
+        return isinstance(self.format, _AsciiColumnFormat)
+
+    @lazyproperty
+    def dtype(self):
+        return self.format.dtype
+
+    def copy(self):
+        """
+        Return a copy of this `Column`.
+        """
+        tmp = Column(format='I')  # just use a throw-away format
+        tmp.__dict__ = self.__dict__.copy()
+        return tmp
+
+    @staticmethod
+    def _convert_format(format, cls):
+        """The format argument to this class's initializer may come in many
+        forms.  This uses the given column format class ``cls`` to convert
+        to a format of that type.
+
+        TODO: There should be an abc base class for column format classes
+        """
+
+        # Short circuit in case we're already a _BaseColumnFormat--there is at
+        # least one case in which this can happen
+        if isinstance(format, _BaseColumnFormat):
+            return format, format.recformat
+
+        if format in NUMPY2FITS:
+            with suppress(VerifyError):
+                # legit recarray format?
+                recformat = format
+                format = cls.from_recformat(format)
+
+        try:
+            # legit FITS format?
+            format = cls(format)
+            recformat = format.recformat
+        except VerifyError:
+            raise VerifyError('Illegal format `{}`.'.format(format))
+
+        return format, recformat
+
+    @classmethod
+    def _verify_keywords(cls, name=None, format=None, unit=None, null=None,
+                         bscale=None, bzero=None, disp=None, start=None,
+                         dim=None, ascii=None, coord_type=None, coord_unit=None,
+                         coord_ref_point=None, coord_ref_value=None,
+                         coord_inc=None, time_ref_pos=None):
+        """
+        Given the keyword arguments used to initialize a Column, specifically
+        those that typically read from a FITS header (so excluding array),
+        verify that each keyword has a valid value.
+
+        Returns a 2-tuple of dicts.  The first maps valid keywords to their
+        values.  The second maps invalid keywords to a 2-tuple of their value,
+        and a message explaining why they were found invalid.
+        """
+
+        valid = {}
+        invalid = {}
+
+        format, recformat = cls._determine_formats(format, start, dim, ascii)
+        valid.update(format=format, recformat=recformat)
+
+        # Currently we don't have any validation for name, unit, bscale, or
+        # bzero so include those by default
+        # TODO: Add validation for these keywords, obviously
+        for k, v in [('name', name), ('unit', unit), ('bscale', bscale),
+                     ('bzero', bzero)]:
+            if v is not None and v != '':
+                valid[k] = v
+
+        # Validate null option
+        # Note: Enough code exists that thinks empty strings are sensible
+        # inputs for these options that we need to treat '' as None
+        if null is not None and null != '':
+            msg = None
+            if isinstance(format, _AsciiColumnFormat):
+                null = str(null)
+                if len(null) > format.width:
+                    msg = (
+                        "ASCII table null option (TNULLn) is longer than "
+                        "the column's character width and will be truncated "
+                        "(got {!r}).".format(null))
+            else:
+                tnull_formats = ('B', 'I', 'J', 'K')
+
+                if not _is_int(null):
+                    # Make this an exception instead of a warning, since any
+                    # non-int value is meaningless
+                    msg = (
+                        'Column null option (TNULLn) must be an integer for '
+                        'binary table columns (got {!r}).  The invalid value '
+                        'will be ignored for the purpose of formatting '
+                        'the data in this column.'.format(null))
+
+                elif not (format.format in tnull_formats or
+                          (format.format in ('P', 'Q') and
+                           format.p_format in tnull_formats)):
+                    # TODO: We should also check that TNULLn's integer value
+                    # is in the range allowed by the column's format
+                    msg = (
+                        'Column null option (TNULLn) is invalid for binary '
+                        'table columns of type {!r} (got {!r}).  The invalid '
+                        'value will be ignored for the purpose of formatting '
+                        'the data in this column.'.format(format, null))
+
+            if msg is None:
+                valid['null'] = null
+            else:
+                invalid['null'] = (null, msg)
+
+        # Validate the disp option
+        # TODO: Add full parsing and validation of TDISPn keywords
+        if disp is not None and disp != '':
+            msg = None
+            if not isinstance(disp, str):
+                msg = (
+                    'Column disp option (TDISPn) must be a string (got {!r}).'
+                    'The invalid value will be ignored for the purpose of '
+                    'formatting the data in this column.'.format(disp))
+
+            elif (isinstance(format, _AsciiColumnFormat) and
+                    disp[0].upper() == 'L'):
+                # disp is at least one character long and has the 'L' format
+                # which is not recognized for ASCII tables
+                msg = (
+                    "Column disp option (TDISPn) may not use the 'L' format "
+                    "with ASCII table columns.  The invalid value will be "
+                    "ignored for the purpose of formatting the data in this "
+                    "column.")
+
+            if msg is None:
+                valid['disp'] = disp
+            else:
+                invalid['disp'] = (disp, msg)
+
+        # Validate the start option
+        if start is not None and start != '':
+            msg = None
+            if not isinstance(format, _AsciiColumnFormat):
+                # The 'start' option only applies to ASCII columns
+                msg = (
+                    'Column start option (TBCOLn) is not allowed for binary '
+                    'table columns (got {!r}).  The invalid keyword will be '
+                    'ignored for the purpose of formatting the data in this '
+                    'column.'.format(start))
+            else:
+                try:
+                    start = int(start)
+                except (TypeError, ValueError):
+                    pass
+
+                if not _is_int(start) or start < 1:
+                    msg = (
+                        'Column start option (TBCOLn) must be a positive integer '
+                        '(got {!r}).  The invalid value will be ignored for the '
+                        'purpose of formatting the data in this column.'.format(start))
+
+            if msg is None:
+                valid['start'] = start
+            else:
+                invalid['start'] = (start, msg)
+
+        # Process TDIMn options
+        # ASCII table columns can't have a TDIMn keyword associated with it;
+        # for now we just issue a warning and ignore it.
+        # TODO: This should be checked by the FITS verification code
+        if dim is not None and dim != '':
+            msg = None
+            dims_tuple = tuple()
+            # NOTE: If valid, the dim keyword's value in the the valid dict is
+            # a tuple, not the original string; if invalid just the original
+            # string is returned
+            if isinstance(format, _AsciiColumnFormat):
+                msg = (
+                    'Column dim option (TDIMn) is not allowed for ASCII table '
+                    'columns (got {!r}).  The invalid keyword will be ignored '
+                    'for the purpose of formatting this column.'.format(dim))
+
+            elif isinstance(dim, str):
+                dims_tuple = _parse_tdim(dim)
+            elif isinstance(dim, tuple):
+                dims_tuple = dim
+            else:
+                msg = (
+                    "`dim` argument must be a string containing a valid value "
+                    "for the TDIMn header keyword associated with this column, "
+                    "or a tuple containing the C-order dimensions for the "
+                    "column.  The invalid value will be ignored for the purpose "
+                    "of formatting this column.")
+
+            if dims_tuple:
+                if reduce(operator.mul, dims_tuple) > format.repeat:
+                    msg = (
+                        "The repeat count of the column format {!r} for column {!r} "
+                        "is fewer than the number of elements per the TDIM "
+                        "argument {!r}.  The invalid TDIMn value will be ignored "
+                        "for the purpose of formatting this column.".format(
+                            name, format, dim))
+
+            if msg is None:
+                valid['dim'] = dims_tuple
+            else:
+                invalid['dim'] = (dim, msg)
+
+        if coord_type is not None and coord_type != '':
+            msg = None
+            if not isinstance(coord_type, str):
+                msg = (
+                    "Coordinate/axis type option (TCTYPn) must be a string "
+                    "(got {!r}). The invalid keyword will be ignored for the "
+                    "purpose of formatting this column.".format(coord_type))
+            elif len(coord_type) > 8:
+                msg = (
+                    "Coordinate/axis type option (TCTYPn) must be a string "
+                    "of atmost 8 characters (got {!r}). The invalid keyword "
+                    "will be ignored for the purpose of formatting this "
+                    "column.".format(coord_type))
+
+            if msg is None:
+                valid['coord_type'] = coord_type
+            else:
+                invalid['coord_type'] = (coord_type, msg)
+
+        if coord_unit is not None and coord_unit != '':
+            msg = None
+            if not isinstance(coord_unit, str):
+                msg = (
+                    "Coordinate/axis unit option (TCUNIn) must be a string "
+                    "(got {!r}). The invalid keyword will be ignored for the "
+                    "purpose of formatting this column.".format(coord_unit))
+
+            if msg is None:
+                valid['coord_unit'] = coord_unit
+            else:
+                invalid['coord_unit'] = (coord_unit, msg)
+
+        for k, v in [('coord_ref_point', coord_ref_point),
+                     ('coord_ref_value', coord_ref_value),
+                     ('coord_inc', coord_inc)]:
+            if v is not None and v != '':
+                msg = None
+                if not isinstance(v, numbers.Real):
+                    msg = (
+                        "Column {} option ({}n) must be a real floating type (got {!r}). "
+                        "The invalid value will be ignored for the purpose of formatting "
+                        "the data in this column.".format(k, ATTRIBUTE_TO_KEYWORD[k], v))
+
+                if msg is None:
+                    valid[k] = v
+                else:
+                    invalid[k] = (v, msg)
+
+        if time_ref_pos is not None and time_ref_pos != '':
+            msg=None
+            if not isinstance(time_ref_pos, str):
+                msg = (
+                    "Time coordinate reference position option (TRPOSn) must be "
+                    "a string (got {!r}). The invalid keyword will be ignored for "
+                    "the purpose of formatting this column.".format(time_ref_pos))
+
+            if msg is None:
+                valid['time_ref_pos'] = time_ref_pos
+            else:
+                invalid['time_ref_pos'] = (time_ref_pos, msg)
+
+        return valid, invalid
+
+    @classmethod
+    def _determine_formats(cls, format, start, dim, ascii):
+        """
+        Given a format string and whether or not the Column is for an
+        ASCII table (ascii=None means unspecified, but lean toward binary table
+        where ambiguous) create an appropriate _BaseColumnFormat instance for
+        the column's format, and determine the appropriate recarray format.
+
+        The values of the start and dim keyword arguments are also useful, as
+        the former is only valid for ASCII tables and the latter only for
+        BINARY tables.
+        """
+
+        # If the given format string is unambiguously a Numpy dtype or one of
+        # the Numpy record format type specifiers supported by Astropy then that
+        # should take priority--otherwise assume it is a FITS format
+        if isinstance(format, np.dtype):
+            format, _, _ = _dtype_to_recformat(format)
+
+        # check format
+        if ascii is None and not isinstance(format, _BaseColumnFormat):
+            # We're just give a string which could be either a Numpy format
+            # code, or a format for a binary column array *or* a format for an
+            # ASCII column array--there may be many ambiguities here.  Try our
+            # best to guess what the user intended.
+            format, recformat = cls._guess_format(format, start, dim)
+        elif not ascii and not isinstance(format, _BaseColumnFormat):
+            format, recformat = cls._convert_format(format, _ColumnFormat)
+        elif ascii and not isinstance(format, _AsciiColumnFormat):
+            format, recformat = cls._convert_format(format,
+                                                    _AsciiColumnFormat)
+        else:
+            # The format is already acceptable and unambiguous
+            recformat = format.recformat
+
+        return format, recformat
+
+    @classmethod
+    def _guess_format(cls, format, start, dim):
+        if start and dim:
+            # This is impossible; this can't be a valid FITS column
+            raise ValueError(
+                'Columns cannot have both a start (TCOLn) and dim '
+                '(TDIMn) option, since the former is only applies to '
+                'ASCII tables, and the latter is only valid for binary '
+                'tables.')
+        elif start:
+            # Only ASCII table columns can have a 'start' option
+            guess_format = _AsciiColumnFormat
+        elif dim:
+            # Only binary tables can have a dim option
+            guess_format = _ColumnFormat
+        else:
+            # If the format is *technically* a valid binary column format
+            # (i.e. it has a valid format code followed by arbitrary
+            # "optional" codes), but it is also strictly a valid ASCII
+            # table format, then assume an ASCII table column was being
+            # requested (the more likely case, after all).
+            with suppress(VerifyError):
+                format = _AsciiColumnFormat(format, strict=True)
+
+            # A safe guess which reflects the existing behavior of previous
+            # Astropy versions
+            guess_format = _ColumnFormat
+
+        try:
+            format, recformat = cls._convert_format(format, guess_format)
+        except VerifyError:
+            # For whatever reason our guess was wrong (for example if we got
+            # just 'F' that's not a valid binary format, but it an ASCII format
+            # code albeit with the width/precision omitted
+            guess_format = (_AsciiColumnFormat
+                            if guess_format is _ColumnFormat
+                            else _ColumnFormat)
+            # If this fails too we're out of options--it is truly an invalid
+            # format, or at least not supported
+            format, recformat = cls._convert_format(format, guess_format)
+
+        return format, recformat
+
+    def _convert_to_valid_data_type(self, array):
+        # Convert the format to a type we understand
+        if isinstance(array, Delayed):
+            return array
+        elif array is None:
+            return array
+        else:
+            format = self.format
+            dims = self._dims
+
+            if dims:
+                shape = dims[:-1] if 'A' in format else dims
+                shape = (len(array),) + shape
+                array = array.reshape(shape)
+
+            if 'P' in format or 'Q' in format:
+                return array
+            elif 'A' in format:
+                if array.dtype.char in 'SU':
+                    if dims:
+                        # The 'last' dimension (first in the order given
+                        # in the TDIMn keyword itself) is the number of
+                        # characters in each string
+                        fsize = dims[-1]
+                    else:
+                        fsize = np.dtype(format.recformat).itemsize
+                    return chararray.array(array, itemsize=fsize, copy=False)
+                else:
+                    return _convert_array(array, np.dtype(format.recformat))
+            elif 'L' in format:
+                # boolean needs to be scaled back to storage values ('T', 'F')
+                if array.dtype == np.dtype('bool'):
+                    return np.where(array == np.False_, ord('F'), ord('T'))
+                else:
+                    return np.where(array == 0, ord('F'), ord('T'))
+            elif 'X' in format:
+                return _convert_array(array, np.dtype('uint8'))
+            else:
+                # Preserve byte order of the original array for now; see #77
+                numpy_format = array.dtype.byteorder + format.recformat
+
+                # Handle arrays passed in as unsigned ints as pseudo-unsigned
+                # int arrays; blatantly tacked in here for now--we need columns
+                # to have explicit knowledge of whether they treated as
+                # pseudo-unsigned
+                bzeros = {2: np.uint16(2**15), 4: np.uint32(2**31),
+                          8: np.uint64(2**63)}
+                if (array.dtype.kind == 'u' and
+                        array.dtype.itemsize in bzeros and
+                        self.bscale in (1, None, '') and
+                        self.bzero == bzeros[array.dtype.itemsize]):
+                    # Basically the array is uint, has scale == 1.0, and the
+                    # bzero is the appropriate value for a pseudo-unsigned
+                    # integer of the input dtype, then go ahead and assume that
+                    # uint is assumed
+                    numpy_format = numpy_format.replace('i', 'u')
+                    self._pseudo_unsigned_ints = True
+
+                # The .base here means we're dropping the shape information,
+                # which is only used to format recarray fields, and is not
+                # useful for converting input arrays to the correct data type
+                dtype = np.dtype(numpy_format).base
+
+                return _convert_array(array, dtype)
+
+
+class ColDefs(NotifierMixin):
+    """
+    Column definitions class.
+
+    It has attributes corresponding to the `Column` attributes
+    (e.g. `ColDefs` has the attribute ``names`` while `Column`
+    has ``name``). Each attribute in `ColDefs` is a list of
+    corresponding attribute values from all `Column` objects.
+    """
+
+    _padding_byte = '\x00'
+    _col_format_cls = _ColumnFormat
+
+    def __new__(cls, input, ascii=False):
+        klass = cls
+
+        if (hasattr(input, '_columns_type') and
+                issubclass(input._columns_type, ColDefs)):
+            klass = input._columns_type
+        elif (hasattr(input, '_col_format_cls') and
+                issubclass(input._col_format_cls, _AsciiColumnFormat)):
+            klass = _AsciiColDefs
+
+        if ascii:  # force ASCII if this has been explicitly requested
+            klass = _AsciiColDefs
+
+        return object.__new__(klass)
+
+    def __getnewargs__(self):
+        return (self._arrays,)
+
+    def __init__(self, input, ascii=False):
+        """
+        Parameters
+        ----------
+
+        input : sequence of `Column`, `ColDefs`, other
+            An existing table HDU, an existing `ColDefs`, or any multi-field
+            Numpy array or `numpy.recarray`.
+
+        ascii : bool
+            Use True to ensure that ASCII table columns are used.
+
+        """
+        from .hdu.table import _TableBaseHDU
+        from .fitsrec import FITS_rec
+
+        if isinstance(input, ColDefs):
+            self._init_from_coldefs(input)
+        elif (isinstance(input, FITS_rec) and hasattr(input, '_coldefs') and
+                input._coldefs):
+            # If given a FITS_rec object we can directly copy its columns, but
+            # only if its columns have already been defined, otherwise this
+            # will loop back in on itself and blow up
+            self._init_from_coldefs(input._coldefs)
+        elif isinstance(input, np.ndarray) and input.dtype.fields is not None:
+            # Construct columns from the fields of a record array
+            self._init_from_array(input)
+        elif isiterable(input):
+            # if the input is a list of Columns
+            self._init_from_sequence(input)
+        elif isinstance(input, _TableBaseHDU):
+            # Construct columns from fields in an HDU header
+            self._init_from_table(input)
+        else:
+            raise TypeError('Input to ColDefs must be a table HDU, a list '
+                            'of Columns, or a record/field array.')
+
+        # Listen for changes on all columns
+        for col in self.columns:
+            col._add_listener(self)
+
+    def _init_from_coldefs(self, coldefs):
+        """Initialize from an existing ColDefs object (just copy the
+        columns and convert their formats if necessary).
+        """
+
+        self.columns = [self._copy_column(col) for col in coldefs]
+
+    def _init_from_sequence(self, columns):
+        for idx, col in enumerate(columns):
+            if not isinstance(col, Column):
+                raise TypeError('Element {} in the ColDefs input is not a '
+                                'Column.'.format(idx))
+
+        self._init_from_coldefs(columns)
+
+    def _init_from_array(self, array):
+        self.columns = []
+        for idx in range(len(array.dtype)):
+            cname = array.dtype.names[idx]
+            ftype = array.dtype.fields[cname][0]
+            format = self._col_format_cls.from_recformat(ftype)
+
+            # Determine the appropriate dimensions for items in the column
+            # (typically just 1D)
+            dim = array.dtype[idx].shape[::-1]
+            if dim and (len(dim) > 1 or 'A' in format):
+                if 'A' in format:
+                    # n x m string arrays must include the max string
+                    # length in their dimensions (e.g. l x n x m)
+                    dim = (array.dtype[idx].base.itemsize,) + dim
+                dim = repr(dim).replace(' ', '')
+            else:
+                dim = None
+
+            # Check for unsigned ints.
+            bzero = None
+            if ftype.base.kind == 'u':
+                if 'I' in format:
+                    bzero = np.uint16(2**15)
+                elif 'J' in format:
+                    bzero = np.uint32(2**31)
+                elif 'K' in format:
+                    bzero = np.uint64(2**63)
+
+            c = Column(name=cname, format=format,
+                       array=array.view(np.ndarray)[cname], bzero=bzero,
+                       dim=dim)
+            self.columns.append(c)
+
+    def _init_from_table(self, table):
+        hdr = table._header
+        nfields = hdr['TFIELDS']
+
+        # go through header keywords to pick out column definition keywords
+        # definition dictionaries for each field
+        col_keywords = [{} for i in range(nfields)]
+        for keyword, value in hdr.items():
+            key = TDEF_RE.match(keyword)
+            try:
+                keyword = key.group('label')
+            except Exception:
+                continue  # skip if there is no match
+            if keyword in KEYWORD_NAMES:
+                col = int(key.group('num'))
+                if 0 < col <= nfields:
+                    attr = KEYWORD_TO_ATTRIBUTE[keyword]
+                    if attr == 'format':
+                        # Go ahead and convert the format value to the
+                        # appropriate ColumnFormat container now
+                        value = self._col_format_cls(value)
+                    col_keywords[col - 1][attr] = value
+
+        # Verify the column keywords and display any warnings if necessary;
+        # we only want to pass on the valid keywords
+        for idx, kwargs in enumerate(col_keywords):
+            valid_kwargs, invalid_kwargs = Column._verify_keywords(**kwargs)
+            for val in invalid_kwargs.values():
+                warnings.warn(
+                    'Invalid keyword for column {}: {}'.format(idx + 1, val[1]),
+                    VerifyWarning)
+            # Special cases for recformat and dim
+            # TODO: Try to eliminate the need for these special cases
+            del valid_kwargs['recformat']
+            if 'dim' in valid_kwargs:
+                valid_kwargs['dim'] = kwargs['dim']
+            col_keywords[idx] = valid_kwargs
+
+        # data reading will be delayed
+        for col in range(nfields):
+            col_keywords[col]['array'] = Delayed(table, col)
+
+        # now build the columns
+        self.columns = [Column(**attrs) for attrs in col_keywords]
+
+        # Add the table HDU is a listener to changes to the columns
+        # (either changes to individual columns, or changes to the set of
+        # columns (add/remove/etc.))
+        self._add_listener(table)
+
+    def __copy__(self):
+        return self.__class__(self)
+
+    def __deepcopy__(self, memo):
+        return self.__class__([copy.deepcopy(c, memo) for c in self.columns])
+
+    def _copy_column(self, column):
+        """Utility function used currently only by _init_from_coldefs
+        to help convert columns from binary format to ASCII format or vice
+        versa if necessary (otherwise performs a straight copy).
+        """
+
+        if isinstance(column.format, self._col_format_cls):
+            # This column has a FITS format compatible with this column
+            # definitions class (that is ascii or binary)
+            return column.copy()
+
+        new_column = column.copy()
+
+        # Try to use the Numpy recformat as the equivalency between the
+        # two formats; if that conversion can't be made then these
+        # columns can't be transferred
+        # TODO: Catch exceptions here and raise an explicit error about
+        # column format conversion
+        new_column.format = self._col_format_cls.from_column_format(
+                column.format)
+
+        # Handle a few special cases of column format options that are not
+        # compatible between ASCII an binary tables
+        # TODO: This is sort of hacked in right now; we really need
+        # separate classes for ASCII and Binary table Columns, and they
+        # should handle formatting issues like these
+        if not isinstance(new_column.format, _AsciiColumnFormat):
+            # the column is a binary table column...
+            new_column.start = None
+            if new_column.null is not None:
+                # We can't just "guess" a value to represent null
+                # values in the new column, so just disable this for
+                # now; users may modify it later
+                new_column.null = None
+        else:
+            # the column is an ASCII table column...
+            if new_column.null is not None:
+                new_column.null = DEFAULT_ASCII_TNULL
+            if (new_column.disp is not None and
+                    new_column.disp.upper().startswith('L')):
+                # ASCII columns may not use the logical data display format;
+                # for now just drop the TDISPn option for this column as we
+                # don't have a systematic conversion of boolean data to ASCII
+                # tables yet
+                new_column.disp = None
+
+        return new_column
+
+    def __getattr__(self, name):
+        """
+        Automatically returns the values for the given keyword attribute for
+        all `Column`s in this list.
+
+        Implements for example self.units, self.formats, etc.
+        """
+        cname = name[:-1]
+        if cname in KEYWORD_ATTRIBUTES and name[-1] == 's':
+            attr = []
+            for col in self.columns:
+                val = getattr(col, cname)
+                attr.append(val if val is not None else '')
+            return attr
+        raise AttributeError(name)
+
+    @lazyproperty
+    def dtype(self):
+        # Note: This previously returned a dtype that just used the raw field
+        # widths based on the format's repeat count, and did not incorporate
+        # field *shapes* as provided by TDIMn keywords.
+        # Now this incorporates TDIMn from the start, which makes *this* method
+        # a little more complicated, but simplifies code elsewhere (for example
+        # fields will have the correct shapes even in the raw recarray).
+        formats = []
+        offsets = [0]
+
+        for format_, dim in zip(self.formats, self._dims):
+            dt = format_.dtype
+
+            if len(offsets) < len(self.formats):
+                # Note: the size of the *original* format_ may be greater than
+                # one would expect from the number of elements determined by
+                # dim.  The FITS format allows this--the rest of the field is
+                # filled with undefined values.
+                offsets.append(offsets[-1] + dt.itemsize)
+
+            if dim:
+                if format_.format == 'A':
+                    dt = np.dtype((dt.char + str(dim[-1]), dim[:-1]))
+                else:
+                    dt = np.dtype((dt.base, dim))
+
+            formats.append(dt)
+
+        return np.dtype({'names': self.names,
+                         'formats': formats,
+                         'offsets': offsets})
+
+    @lazyproperty
+    def names(self):
+        return [col.name for col in self.columns]
+
+    @lazyproperty
+    def formats(self):
+        return [col.format for col in self.columns]
+
+    @lazyproperty
+    def _arrays(self):
+        return [col.array for col in self.columns]
+
+    @lazyproperty
+    def _recformats(self):
+        return [fmt.recformat for fmt in self.formats]
+
+    @lazyproperty
+    def _dims(self):
+        """Returns the values of the TDIMn keywords parsed into tuples."""
+
+        return [col._dims for col in self.columns]
+
+    def __getitem__(self, key):
+        if isinstance(key, str):
+            key = _get_index(self.names, key)
+
+        x = self.columns[key]
+        if _is_int(key):
+            return x
+        else:
+            return ColDefs(x)
+
+    def __len__(self):
+        return len(self.columns)
+
+    def __repr__(self):
+        rep = 'ColDefs('
+        if hasattr(self, 'columns') and self.columns:
+            # The hasattr check is mostly just useful in debugging sessions
+            # where self.columns may not be defined yet
+            rep += '\n    '
+            rep += '\n    '.join([repr(c) for c in self.columns])
+            rep += '\n'
+        rep += ')'
+        return rep
+
+    def __add__(self, other, option='left'):
+        if isinstance(other, Column):
+            b = [other]
+        elif isinstance(other, ColDefs):
+            b = list(other.columns)
+        else:
+            raise TypeError('Wrong type of input.')
+        if option == 'left':
+            tmp = list(self.columns) + b
+        else:
+            tmp = b + list(self.columns)
+        return ColDefs(tmp)
+
+    def __radd__(self, other):
+        return self.__add__(other, 'right')
+
+    def __sub__(self, other):
+        if not isinstance(other, (list, tuple)):
+            other = [other]
+        _other = [_get_index(self.names, key) for key in other]
+        indx = list(range(len(self)))
+        for x in _other:
+            indx.remove(x)
+        tmp = [self[i] for i in indx]
+        return ColDefs(tmp)
+
+    def _update_column_attribute_changed(self, column, attr, old_value,
+                                         new_value):
+        """
+        Handle column attribute changed notifications from columns that are
+        members of this `ColDefs`.
+
+        `ColDefs` itself does not currently do anything with this, and just
+        bubbles the notification up to any listening table HDUs that may need
+        to update their headers, etc.  However, this also informs the table of
+        the numerical index of the column that changed.
+        """
+
+        idx = 0
+        for idx, col in enumerate(self.columns):
+            if col is column:
+                break
+
+        if attr == 'name':
+            del self.names
+        elif attr == 'format':
+            del self.formats
+
+        self._notify('column_attribute_changed', column, idx, attr, old_value,
+                     new_value)
+
+    def add_col(self, column):
+        """
+        Append one `Column` to the column definition.
+        """
+
+        if not isinstance(column, Column):
+            raise AssertionError
+
+        self._arrays.append(column.array)
+        # Obliterate caches of certain things
+        del self.dtype
+        del self._recformats
+        del self._dims
+        del self.names
+        del self.formats
+
+        self.columns.append(column)
+
+        # Listen for changes on the new column
+        column._add_listener(self)
+
+        # If this ColDefs is being tracked by a Table, inform the
+        # table that its data is now invalid.
+        self._notify('column_added', self, column)
+        return self
+
+    def del_col(self, col_name):
+        """
+        Delete (the definition of) one `Column`.
+
+        col_name : str or int
+            The column's name or index
+        """
+
+        indx = _get_index(self.names, col_name)
+        col = self.columns[indx]
+
+        del self._arrays[indx]
+        # Obliterate caches of certain things
+        del self.dtype
+        del self._recformats
+        del self._dims
+        del self.names
+        del self.formats
+
+        del self.columns[indx]
+
+        col._remove_listener(self)
+
+        # If this ColDefs is being tracked by a table HDU, inform the HDU (or
+        # any other listeners) that the column has been removed
+        # Just send a reference to self, and the index of the column that was
+        # removed
+        self._notify('column_removed', self, indx)
+        return self
+
+    def change_attrib(self, col_name, attrib, new_value):
+        """
+        Change an attribute (in the ``KEYWORD_ATTRIBUTES`` list) of a `Column`.
+
+        Parameters
+        ----------
+        col_name : str or int
+            The column name or index to change
+
+        attrib : str
+            The attribute name
+
+        new_value : object
+            The new value for the attribute
+        """
+
+        setattr(self[col_name], attrib, new_value)
+
+    def change_name(self, col_name, new_name):
+        """
+        Change a `Column`'s name.
+
+        Parameters
+        ----------
+        col_name : str
+            The current name of the column
+
+        new_name : str
+            The new name of the column
+        """
+
+        if new_name != col_name and new_name in self.names:
+            raise ValueError('New name {} already exists.'.format(new_name))
+        else:
+            self.change_attrib(col_name, 'name', new_name)
+
+    def change_unit(self, col_name, new_unit):
+        """
+        Change a `Column`'s unit.
+
+        Parameters
+        ----------
+        col_name : str or int
+            The column name or index
+
+        new_unit : str
+            The new unit for the column
+        """
+
+        self.change_attrib(col_name, 'unit', new_unit)
+
+    def info(self, attrib='all', output=None):
+        """
+        Get attribute(s) information of the column definition.
+
+        Parameters
+        ----------
+        attrib : str
+            Can be one or more of the attributes listed in
+            ``astropy.io.fits.column.KEYWORD_ATTRIBUTES``.  The default is
+            ``"all"`` which will print out all attributes.  It forgives plurals
+            and blanks.  If there are two or more attribute names, they must be
+            separated by comma(s).
+
+        output : file, optional
+            File-like object to output to.  Outputs to stdout by default.
+            If `False`, returns the attributes as a `dict` instead.
+
+        Notes
+        -----
+        This function doesn't return anything by default; it just prints to
+        stdout.
+        """
+
+        if output is None:
+            output = sys.stdout
+
+        if attrib.strip().lower() in ['all', '']:
+            lst = KEYWORD_ATTRIBUTES
+        else:
+            lst = attrib.split(',')
+            for idx in range(len(lst)):
+                lst[idx] = lst[idx].strip().lower()
+                if lst[idx][-1] == 's':
+                    lst[idx] = list[idx][:-1]
+
+        ret = {}
+
+        for attr in lst:
+            if output:
+                if attr not in KEYWORD_ATTRIBUTES:
+                    output.write("'{}' is not an attribute of the column "
+                                 "definitions.\n".format(attr))
+                    continue
+                output.write("{}:\n".format(attr))
+                output.write('    {}\n'.format(getattr(self, attr + 's')))
+            else:
+                ret[attr] = getattr(self, attr + 's')
+
+        if not output:
+            return ret
+
+
+class _AsciiColDefs(ColDefs):
+    """ColDefs implementation for ASCII tables."""
+
+    _padding_byte = ' '
+    _col_format_cls = _AsciiColumnFormat
+
+    def __init__(self, input, ascii=True):
+        super().__init__(input)
+
+        # if the format of an ASCII column has no width, add one
+        if not isinstance(input, _AsciiColDefs):
+            self._update_field_metrics()
+        else:
+            for idx, s in enumerate(input.starts):
+                self.columns[idx].start = s
+
+            self._spans = input.spans
+            self._width = input._width
+
+    @lazyproperty
+    def dtype(self):
+        dtype = {}
+
+        for j in range(len(self)):
+            data_type = 'S' + str(self.spans[j])
+            dtype[self.names[j]] = (data_type, self.starts[j] - 1)
+
+        return np.dtype(dtype)
+
+    @property
+    def spans(self):
+        """A list of the widths of each field in the table."""
+
+        return self._spans
+
+    @lazyproperty
+    def _recformats(self):
+        if len(self) == 1:
+            widths = []
+        else:
+            widths = [y - x for x, y in pairwise(self.starts)]
+
+        # Widths is the width of each field *including* any space between
+        # fields; this is so that we can map the fields to string records in a
+        # Numpy recarray
+        widths.append(self._width - self.starts[-1] + 1)
+        return ['a' + str(w) for w in widths]
+
+    def add_col(self, column):
+        super().add_col(column)
+        self._update_field_metrics()
+
+    def del_col(self, col_name):
+        super().del_col(col_name)
+        self._update_field_metrics()
+
+    def _update_field_metrics(self):
+        """
+        Updates the list of the start columns, the list of the widths of each
+        field, and the total width of each record in the table.
+        """
+
+        spans = [0] * len(self.columns)
+        end_col = 0  # Refers to the ASCII text column, not the table col
+        for idx, col in enumerate(self.columns):
+            width = col.format.width
+
+            # Update the start columns and column span widths taking into
+            # account the case that the starting column of a field may not
+            # be the column immediately after the previous field
+            if not col.start:
+                col.start = end_col + 1
+            end_col = col.start + width - 1
+            spans[idx] = width
+
+        self._spans = spans
+        self._width = end_col
+
+
+# Utilities
+
+
+class _VLF(np.ndarray):
+    """Variable length field object."""
+
+    def __new__(cls, input, dtype='a'):
+        """
+        Parameters
+        ----------
+        input
+            a sequence of variable-sized elements.
+        """
+
+        if dtype == 'a':
+            try:
+                # this handles ['abc'] and [['a','b','c']]
+                # equally, beautiful!
+                input = [chararray.array(x, itemsize=1) for x in input]
+            except Exception:
+                raise ValueError(
+                    'Inconsistent input data array: {0}'.format(input))
+
+        a = np.array(input, dtype=object)
+        self = np.ndarray.__new__(cls, shape=(len(input),), buffer=a,
+                                  dtype=object)
+        self.max = 0
+        self.element_dtype = dtype
+        return self
+
+    def __array_finalize__(self, obj):
+        if obj is None:
+            return
+        self.max = obj.max
+        self.element_dtype = obj.element_dtype
+
+    def __setitem__(self, key, value):
+        """
+        To make sure the new item has consistent data type to avoid
+        misalignment.
+        """
+
+        if isinstance(value, np.ndarray) and value.dtype == self.dtype:
+            pass
+        elif isinstance(value, chararray.chararray) and value.itemsize == 1:
+            pass
+        elif self.element_dtype == 'a':
+            value = chararray.array(value, itemsize=1)
+        else:
+            value = np.array(value, dtype=self.element_dtype)
+        np.ndarray.__setitem__(self, key, value)
+        self.max = max(self.max, len(value))
+
+
+def _get_index(names, key):
+    """
+    Get the index of the ``key`` in the ``names`` list.
+
+    The ``key`` can be an integer or string.  If integer, it is the index
+    in the list.  If string,
+
+        a. Field (column) names are case sensitive: you can have two
+           different columns called 'abc' and 'ABC' respectively.
+
+        b. When you *refer* to a field (presumably with the field
+           method), it will try to match the exact name first, so in
+           the example in (a), field('abc') will get the first field,
+           and field('ABC') will get the second field.
+
+        If there is no exact name matched, it will try to match the
+        name with case insensitivity.  So, in the last example,
+        field('Abc') will cause an exception since there is no unique
+        mapping.  If there is a field named "XYZ" and no other field
+        name is a case variant of "XYZ", then field('xyz'),
+        field('Xyz'), etc. will get this field.
+    """
+
+    if _is_int(key):
+        indx = int(key)
+    elif isinstance(key, str):
+        # try to find exact match first
+        try:
+            indx = names.index(key.rstrip())
+        except ValueError:
+            # try to match case-insentively,
+            _key = key.lower().rstrip()
+            names = [n.lower().rstrip() for n in names]
+            count = names.count(_key)  # occurrence of _key in names
+            if count == 1:
+                indx = names.index(_key)
+            elif count == 0:
+                raise KeyError("Key '{}' does not exist.".format(key))
+            else:              # multiple match
+                raise KeyError("Ambiguous key name '{}'.".format(key))
+    else:
+        raise KeyError("Illegal key '{!r}'.".format(key))
+
+    return indx
+
+
+def _unwrapx(input, output, repeat):
+    """
+    Unwrap the X format column into a Boolean array.
+
+    Parameters
+    ----------
+    input
+        input ``Uint8`` array of shape (`s`, `nbytes`)
+
+    output
+        output Boolean array of shape (`s`, `repeat`)
+
+    repeat
+        number of bits
+    """
+
+    pow2 = np.array([128, 64, 32, 16, 8, 4, 2, 1], dtype='uint8')
+    nbytes = ((repeat - 1) // 8) + 1
+    for i in range(nbytes):
+        _min = i * 8
+        _max = min((i + 1) * 8, repeat)
+        for j in range(_min, _max):
+            output[..., j] = np.bitwise_and(input[..., i], pow2[j - i * 8])
+
+
+def _wrapx(input, output, repeat):
+    """
+    Wrap the X format column Boolean array into an ``UInt8`` array.
+
+    Parameters
+    ----------
+    input
+        input Boolean array of shape (`s`, `repeat`)
+
+    output
+        output ``Uint8`` array of shape (`s`, `nbytes`)
+
+    repeat
+        number of bits
+    """
+
+    output[...] = 0  # reset the output
+    nbytes = ((repeat - 1) // 8) + 1
+    unused = nbytes * 8 - repeat
+    for i in range(nbytes):
+        _min = i * 8
+        _max = min((i + 1) * 8, repeat)
+        for j in range(_min, _max):
+            if j != _min:
+                np.left_shift(output[..., i], 1, output[..., i])
+            np.add(output[..., i], input[..., j], output[..., i])
+
+    # shift the unused bits
+    np.left_shift(output[..., i], unused, output[..., i])
+
+
+def _makep(array, descr_output, format, nrows=None):
+    """
+    Construct the P (or Q) format column array, both the data descriptors and
+    the data.  It returns the output "data" array of data type `dtype`.
+
+    The descriptor location will have a zero offset for all columns
+    after this call.  The final offset will be calculated when the file
+    is written.
+
+    Parameters
+    ----------
+    array
+        input object array
+
+    descr_output
+        output "descriptor" array of data type int32 (for P format arrays) or
+        int64 (for Q format arrays)--must be nrows long in its first dimension
+
+    format
+        the _FormatP object representing the format of the variable array
+
+    nrows : int, optional
+        number of rows to create in the column; defaults to the number of rows
+        in the input array
+    """
+
+    # TODO: A great deal of this is redundant with FITS_rec._convert_p; see if
+    # we can merge the two somehow.
+
+    _offset = 0
+
+    if not nrows:
+        nrows = len(array)
+
+    data_output = _VLF([None] * nrows, dtype=format.dtype)
+
+    if format.dtype == 'a':
+        _nbytes = 1
+    else:
+        _nbytes = np.array([], dtype=format.dtype).itemsize
+
+    for idx in range(nrows):
+        if idx < len(array):
+            rowval = array[idx]
+        else:
+            if format.dtype == 'a':
+                rowval = ' ' * data_output.max
+            else:
+                rowval = [0] * data_output.max
+        if format.dtype == 'a':
+            data_output[idx] = chararray.array(encode_ascii(rowval),
+                                               itemsize=1)
+        else:
+            data_output[idx] = np.array(rowval, dtype=format.dtype)
+
+        descr_output[idx, 0] = len(data_output[idx])
+        descr_output[idx, 1] = _offset
+        _offset += len(data_output[idx]) * _nbytes
+
+    return data_output
+
+
+def _parse_tformat(tform):
+    """Parse ``TFORMn`` keyword for a binary table into a
+    ``(repeat, format, option)`` tuple.
+    """
+
+    try:
+        (repeat, format, option) = TFORMAT_RE.match(tform.strip()).groups()
+    except Exception:
+        # TODO: Maybe catch this error use a default type (bytes, maybe?) for
+        # unrecognized column types.  As long as we can determine the correct
+        # byte width somehow..
+        raise VerifyError('Format {!r} is not recognized.'.format(tform))
+
+    if repeat == '':
+        repeat = 1
+    else:
+        repeat = int(repeat)
+
+    return (repeat, format.upper(), option)
+
+
+def _parse_ascii_tformat(tform, strict=False):
+    """
+    Parse the ``TFORMn`` keywords for ASCII tables into a ``(format, width,
+    precision)`` tuple (the latter is always zero unless format is one of 'E',
+    'F', or 'D').
+    """
+
+    match = TFORMAT_ASCII_RE.match(tform.strip())
+    if not match:
+        raise VerifyError('Format {!r} is not recognized.'.format(tform))
+
+    # Be flexible on case
+    format = match.group('format')
+    if format is None:
+        # Floating point format
+        format = match.group('formatf').upper()
+        width = match.group('widthf')
+        precision = match.group('precision')
+        if width is None or precision is None:
+            if strict:
+                raise VerifyError('Format {!r} is not unambiguously an ASCII '
+                                  'table format.')
+            else:
+                width = 0 if width is None else width
+                precision = 1 if precision is None else precision
+    else:
+        format = format.upper()
+        width = match.group('width')
+        if width is None:
+            if strict:
+                raise VerifyError('Format {!r} is not unambiguously an ASCII '
+                                  'table format.')
+            else:
+                # Just use a default width of 0 if unspecified
+                width = 0
+        precision = 0
+
+    def convert_int(val):
+        msg = ('Format {!r} is not valid--field width and decimal precision '
+               'must be integers.')
+        try:
+            val = int(val)
+        except (ValueError, TypeError):
+            raise VerifyError(msg.format(tform))
+
+        return val
+
+    if width and precision:
+        # This should only be the case for floating-point formats
+        width, precision = convert_int(width), convert_int(precision)
+    elif width:
+        # Just for integer/string formats; ignore precision
+        width = convert_int(width)
+    else:
+        # For any format, if width was unspecified use the set defaults
+        width, precision = ASCII_DEFAULT_WIDTHS[format]
+
+    if width <= 0:
+        raise VerifyError("Format {!r} not valid--field width must be a "
+                          "positive integeter.".format(tform))
+
+    if precision >= width:
+        raise VerifyError("Format {!r} not valid--the number of decimal digits "
+                          "must be less than the format's total "
+                          "width {}.".format(tform, width))
+
+    return format, width, precision
+
+
+def _parse_tdim(tdim):
+    """Parse the ``TDIM`` value into a tuple (may return an empty tuple if
+    the value ``TDIM`` value is empty or invalid).
+    """
+
+    m = tdim and TDIM_RE.match(tdim)
+    if m:
+        dims = m.group('dims')
+        return tuple(int(d.strip()) for d in dims.split(','))[::-1]
+
+    # Ignore any dim values that don't specify a multidimensional column
+    return tuple()
+
+
+def _scalar_to_format(value):
+    """
+    Given a scalar value or string, returns the minimum FITS column format
+    that can represent that value.  'minimum' is defined by the order given in
+    FORMATORDER.
+    """
+
+    # First, if value is a string, try to convert to the appropriate scalar
+    # value
+    for type_ in (int, float, complex):
+        try:
+            value = type_(value)
+            break
+        except ValueError:
+            continue
+
+    numpy_dtype_str = np.min_scalar_type(value).str
+    numpy_dtype_str = numpy_dtype_str[1:]  # Strip endianness
+
+    try:
+        fits_format = NUMPY2FITS[numpy_dtype_str]
+        return FITSUPCONVERTERS.get(fits_format, fits_format)
+    except KeyError:
+        return "A" + str(len(value))
+
+
+def _cmp_recformats(f1, f2):
+    """
+    Compares two numpy recformats using the ordering given by FORMATORDER.
+    """
+
+    if f1[0] == 'a' and f2[0] == 'a':
+        return cmp(int(f1[1:]), int(f2[1:]))
+    else:
+        f1, f2 = NUMPY2FITS[f1], NUMPY2FITS[f2]
+        return cmp(FORMATORDER.index(f1), FORMATORDER.index(f2))
+
+
+def _convert_fits2record(format):
+    """
+    Convert FITS format spec to record format spec.
+    """
+
+    repeat, dtype, option = _parse_tformat(format)
+
+    if dtype in FITS2NUMPY:
+        if dtype == 'A':
+            output_format = FITS2NUMPY[dtype] + str(repeat)
+            # to accommodate both the ASCII table and binary table column
+            # format spec, i.e. A7 in ASCII table is the same as 7A in
+            # binary table, so both will produce 'a7'.
+            # Technically the FITS standard does not allow this but it's a very
+            # common mistake
+            if format.lstrip()[0] == 'A' and option != '':
+                # make sure option is integer
+                output_format = FITS2NUMPY[dtype] + str(int(option))
+        else:
+            repeat_str = ''
+            if repeat != 1:
+                repeat_str = str(repeat)
+            output_format = repeat_str + FITS2NUMPY[dtype]
+
+    elif dtype == 'X':
+        output_format = _FormatX(repeat)
+    elif dtype == 'P':
+        output_format = _FormatP.from_tform(format)
+    elif dtype == 'Q':
+        output_format = _FormatQ.from_tform(format)
+    elif dtype == 'F':
+        output_format = 'f8'
+    else:
+        raise ValueError('Illegal format `{}`.'.format(format))
+
+    return output_format
+
+
+def _convert_record2fits(format):
+    """
+    Convert record format spec to FITS format spec.
+    """
+
+    recformat, kind, dtype = _dtype_to_recformat(format)
+    shape = dtype.shape
+    itemsize = dtype.base.itemsize
+    if dtype.char == 'U':
+        # Unicode dtype--itemsize is 4 times actual ASCII character length,
+        # which what matters for FITS column formats
+        # Use dtype.base--dtype may be a multi-dimensional dtype
+        itemsize = itemsize // 4
+
+    option = str(itemsize)
+
+    ndims = len(shape)
+    repeat = 1
+    if ndims > 0:
+        nel = np.array(shape, dtype='i8').prod()
+        if nel > 1:
+            repeat = nel
+
+    if kind == 'a':
+        # This is a kludge that will place string arrays into a
+        # single field, so at least we won't lose data.  Need to
+        # use a TDIM keyword to fix this, declaring as (slength,
+        # dim1, dim2, ...)  as mwrfits does
+
+        ntot = int(repeat) * int(option)
+
+        output_format = str(ntot) + 'A'
+    elif recformat in NUMPY2FITS:  # record format
+        if repeat != 1:
+            repeat = str(repeat)
+        else:
+            repeat = ''
+        output_format = repeat + NUMPY2FITS[recformat]
+    else:
+        raise ValueError('Illegal format `{}`.'.format(format))
+
+    return output_format
+
+
+def _dtype_to_recformat(dtype):
+    """
+    Utility function for converting a dtype object or string that instantiates
+    a dtype (e.g. 'float32') into one of the two character Numpy format codes
+    that have been traditionally used by Astropy.
+
+    In particular, use of 'a' to refer to character data is long since
+    deprecated in Numpy, but Astropy remains heavily invested in its use
+    (something to try to get away from sooner rather than later).
+    """
+
+    if not isinstance(dtype, np.dtype):
+        dtype = np.dtype(dtype)
+
+    kind = dtype.base.kind
+
+    if kind in ('U', 'S'):
+        recformat = kind = 'a'
+    else:
+        itemsize = dtype.base.itemsize
+        recformat = kind + str(itemsize)
+
+    return recformat, kind, dtype
+
+
+def _convert_format(format, reverse=False):
+    """
+    Convert FITS format spec to record format spec.  Do the opposite if
+    reverse=True.
+    """
+
+    if reverse:
+        return _convert_record2fits(format)
+    else:
+        return _convert_fits2record(format)
+
+
+def _convert_ascii_format(format, reverse=False):
+    """Convert ASCII table format spec to record format spec."""
+
+    if reverse:
+        recformat, kind, dtype = _dtype_to_recformat(format)
+        itemsize = dtype.itemsize
+
+        if kind == 'a':
+            return 'A' + str(itemsize)
+        elif NUMPY2FITS.get(recformat) == 'L':
+            # Special case for logical/boolean types--for ASCII tables we
+            # represent these as single character columns containing 'T' or 'F'
+            # (a la the storage format for Logical columns in binary tables)
+            return 'A1'
+        elif kind == 'i':
+            # Use for the width the maximum required to represent integers
+            # of that byte size plus 1 for signs, but use a minimum of the
+            # default width (to keep with existing behavior)
+            width = 1 + len(str(2 ** (itemsize * 8)))
+            width = max(width, ASCII_DEFAULT_WIDTHS['I'][0])
+            return 'I' + str(width)
+        elif kind == 'f':
+            # This is tricky, but go ahead and use D if float-64, and E
+            # if float-32 with their default widths
+            if itemsize >= 8:
+                format = 'D'
+            else:
+                format = 'E'
+            width = '.'.join(str(w) for w in ASCII_DEFAULT_WIDTHS[format])
+            return format + width
+        # TODO: There may be reasonable ways to represent other Numpy types so
+        # let's see what other possibilities there are besides just 'a', 'i',
+        # and 'f'.  If it doesn't have a reasonable ASCII representation then
+        # raise an exception
+    else:
+        format, width, precision = _parse_ascii_tformat(format)
+
+        # This gives a sensible "default" dtype for a given ASCII
+        # format code
+        recformat = ASCII2NUMPY[format]
+
+        # The following logic is taken from CFITSIO:
+        # For integers, if the width <= 4 we can safely use 16-bit ints for all
+        # values [for the non-standard J format code just always force 64-bit]
+        if format == 'I' and width <= 4:
+            recformat = 'i2'
+        elif format == 'A':
+            recformat += str(width)
+
+        return recformat
+
+
+def _parse_tdisp_format(tdisp):
+    """
+    Parse the ``TDISPn`` keywords for ASCII and binary tables into a
+    ``(format, width, precision, exponential)`` tuple (the TDISP values
+    for ASCII and binary are identical except for 'Lw',
+    which is only present in BINTABLE extensions
+
+    Parameters
+    ----------
+    tdisp: str
+        TDISPn FITS Header keyword.  Used to specify display formatting.
+
+    Returns
+    -------
+    formatc: str
+        The format characters from TDISPn
+    width: str
+        The width int value from TDISPn
+    precision: str
+        The precision int value from TDISPn
+    exponential: str
+        The exponential int value from TDISPn
+
+    """
+
+    # Use appropriate regex for format type
+    tdisp = tdisp.strip()
+    fmt_key = tdisp[0] if tdisp[0] !='E' or tdisp[1] not in 'NS' else tdisp[:2]
+    try:
+        tdisp_re = TDISP_RE_DICT[fmt_key]
+    except KeyError:
+        raise VerifyError('Format {} is not recognized.'.format(tdisp))
+
+
+    match = tdisp_re.match(tdisp.strip())
+    if not match or match.group('formatc') is None:
+        raise VerifyError('Format {} is not recognized.'.format(tdisp))
+
+    formatc = match.group('formatc')
+    width = match.group('width')
+    precision = None
+    exponential = None
+
+    # Some formats have precision and exponential
+    if tdisp[0] in ('I', 'B', 'O', 'Z', 'F', 'E', 'G', 'D'):
+        precision = match.group('precision')
+        if precision is None:
+            precision = 1
+    if tdisp[0] in ('E', 'D', 'G') and tdisp[1] not in ('N', 'S'):
+        exponential = match.group('exponential')
+        if exponential is None:
+            exponential = 1
+
+    # Once parsed, check format dict to do conversion to a formatting string
+    return formatc, width, precision, exponential
+
+
+def _fortran_to_python_format(tdisp):
+    """
+    Turn the TDISPn fortran format pieces into a final Python format string.
+    See the format_type definitions above the TDISP_FMT_DICT. If codes is
+    changed to take advantage of the exponential specification, will need to
+    add it as another input parameter.
+
+    Parameters
+    ----------
+    tdisp: str
+        TDISPn FITS Header keyword.  Used to specify display formatting.
+
+    Returns
+    -------
+    format_string: str
+        The TDISPn keyword string translated into a Python format string.
+    """
+    format_type, width, precision, exponential = _parse_tdisp_format(tdisp)
+
+    try:
+        fmt = TDISP_FMT_DICT[format_type]
+        return fmt.format(width=width, precision=precision)
+
+    except KeyError:
+        raise VerifyError('Format {} is not recognized.'.format(format_type))
+
+
+def python_to_tdisp(format_string, logical_dtype = False):
+    """
+    Turn the Python format string to a TDISP FITS compliant format string. Not
+    all formats convert. these will cause a Warning and return None.
+
+    Parameters
+    ----------
+    format_string: str
+        TDISPn FITS Header keyword.  Used to specify display formatting.
+    logical_dtype: bool
+        True is this format type should be a logical type, 'L'. Needs special
+        handeling.
+
+    Returns
+    -------
+    tdsip_string: str
+        The TDISPn keyword string translated into a Python format string.
+    """
+
+    fmt_to_tdisp = {'a': 'A', 's': 'A', 'd': 'I', 'b': 'B', 'o': 'O', 'x': 'Z',
+                    'X': 'Z', 'f': 'F', 'F': 'F', 'g': 'G', 'G': 'G', 'e': 'E',
+                    'E': 'E'}
+
+    if format_string in [None, "", "{}"]:
+        return None
+
+    # Strip out extra format characters that aren't a type or a width/precision
+    if format_string[0] == '{' and format_string != "{}":
+        fmt_str = format_string.lstrip("{:").rstrip('}')
+    elif format_string[0] == '%':
+            fmt_str = format_string.lstrip("%")
+    else:
+        fmt_str = format_string
+
+    precision, sep = '', ''
+
+    # Character format, only translate right aligned, and don't take zero fills
+    if fmt_str[-1].isdigit() and fmt_str[0] == '>' and fmt_str[1] != '0':
+        ftype = fmt_to_tdisp['a']
+        width = fmt_str[1:]
+
+    elif fmt_str[-1] == 's' and fmt_str != 's':
+        ftype = fmt_to_tdisp['a']
+        width = fmt_str[:-1].lstrip('0')
+
+    # Number formats, don't take zero fills
+    elif fmt_str[-1].isalpha() and len(fmt_str) > 1 and fmt_str[0] != '0':
+        ftype = fmt_to_tdisp[fmt_str[-1]]
+        fmt_str = fmt_str[:-1]
+
+        # If format has a "." split out the width and precision
+        if '.' in fmt_str:
+            width, precision = fmt_str.split('.')
+            sep = '.'
+            if width == "":
+                ascii_key = ftype if ftype != 'G' else 'F'
+                width = str(int(precision) + (ASCII_DEFAULT_WIDTHS[ascii_key][0] -
+                                     ASCII_DEFAULT_WIDTHS[ascii_key][1]))
+        # Otherwise we just have a width
+        else:
+            width = fmt_str
+
+    else:
+        warnings.warn('Format {} cannot be mapped to the accepted '
+                      'TDISPn keyword values.  Format will not be '
+                      'moved into TDISPn keyword.'.format(format_string),
+                      AstropyUserWarning)
+        return None
+
+    # Catch logical data type, set the format type back to L in this case
+    if logical_dtype:
+        ftype = 'L'
+
+    return ftype + width + sep + precision

testbed/astropy__astropy/astropy/io/fits/connect.py

@@ -0,0 +1,401 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+
+import os
+import re
+import warnings
+from collections import OrderedDict
+
+from astropy.io import registry as io_registry
+from astropy import units as u
+from astropy.table import Table, serialize, meta, Column, MaskedColumn
+from astropy.table.table import has_info_class
+from astropy.time import Time
+from astropy.utils.exceptions import AstropyUserWarning
+from astropy.utils.data_info import MixinInfo, serialize_context_as
+from . import HDUList, TableHDU, BinTableHDU, GroupsHDU
+from .column import KEYWORD_NAMES, _fortran_to_python_format
+from .convenience import table_to_hdu
+from .hdu.hdulist import fitsopen as fits_open
+from .util import first
+
+
+# FITS file signature as per RFC 4047
+FITS_SIGNATURE = (b"\x53\x49\x4d\x50\x4c\x45\x20\x20\x3d\x20\x20\x20\x20\x20"
+                  b"\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20"
+                  b"\x20\x54")
+
+# Keywords to remove for all tables that are read in
+REMOVE_KEYWORDS = ['XTENSION', 'BITPIX', 'NAXIS', 'NAXIS1', 'NAXIS2',
+                   'PCOUNT', 'GCOUNT', 'TFIELDS', 'THEAP']
+
+# Column-specific keywords regex
+COLUMN_KEYWORD_REGEXP = '(' + '|'.join(KEYWORD_NAMES) + ')[0-9]+'
+
+
+def is_column_keyword(keyword):
+    return re.match(COLUMN_KEYWORD_REGEXP, keyword) is not None
+
+
+def is_fits(origin, filepath, fileobj, *args, **kwargs):
+    """
+    Determine whether `origin` is a FITS file.
+
+    Parameters
+    ----------
+    origin : str or readable file-like object
+        Path or file object containing a potential FITS file.
+
+    Returns
+    -------
+    is_fits : bool
+        Returns `True` if the given file is a FITS file.
+    """
+    if fileobj is not None:
+        pos = fileobj.tell()
+        sig = fileobj.read(30)
+        fileobj.seek(pos)
+        return sig == FITS_SIGNATURE
+    elif filepath is not None:
+        if filepath.lower().endswith(('.fits', '.fits.gz', '.fit', '.fit.gz',
+                                      '.fts', '.fts.gz')):
+            return True
+    elif isinstance(args[0], (HDUList, TableHDU, BinTableHDU, GroupsHDU)):
+        return True
+    else:
+        return False
+
+
+def _decode_mixins(tbl):
+    """Decode a Table ``tbl`` that has astropy Columns + appropriate meta-data into
+    the corresponding table with mixin columns (as appropriate).
+    """
+    # If available read in __serialized_columns__ meta info which is stored
+    # in FITS COMMENTS between two sentinels.
+    try:
+        i0 = tbl.meta['comments'].index('--BEGIN-ASTROPY-SERIALIZED-COLUMNS--')
+        i1 = tbl.meta['comments'].index('--END-ASTROPY-SERIALIZED-COLUMNS--')
+    except (ValueError, KeyError):
+        return tbl
+
+    # The YAML data are split into COMMENT cards, with lines longer than 70
+    # characters being split with a continuation character \ (backslash).
+    # Strip the backslashes and join together.
+    continuation_line = False
+    lines = []
+    for line in tbl.meta['comments'][i0 + 1:i1]:
+        if continuation_line:
+            lines[-1] = lines[-1] + line[:70]
+        else:
+            lines.append(line[:70])
+        continuation_line = len(line) == 71
+
+    del tbl.meta['comments'][i0:i1 + 1]
+    if not tbl.meta['comments']:
+        del tbl.meta['comments']
+    info = meta.get_header_from_yaml(lines)
+
+    # Add serialized column information to table meta for use in constructing mixins
+    tbl.meta['__serialized_columns__'] = info['meta']['__serialized_columns__']
+
+    # Use the `datatype` attribute info to update column attributes that are
+    # NOT already handled via standard FITS column keys (name, dtype, unit).
+    for col in info['datatype']:
+        for attr in ['description', 'meta']:
+            if attr in col:
+                setattr(tbl[col['name']].info, attr, col[attr])
+
+    # Construct new table with mixins, using tbl.meta['__serialized_columns__']
+    # as guidance.
+    tbl = serialize._construct_mixins_from_columns(tbl)
+
+    return tbl
+
+
+def read_table_fits(input, hdu=None, astropy_native=False, memmap=False,
+                    character_as_bytes=True):
+    """
+    Read a Table object from an FITS file
+
+    If the ``astropy_native`` argument is ``True``, then input FITS columns
+    which are representations of an astropy core object will be converted to
+    that class and stored in the ``Table`` as "mixin columns".  Currently this
+    is limited to FITS columns which adhere to the FITS Time standard, in which
+    case they will be converted to a `~astropy.time.Time` column in the output
+    table.
+
+    Parameters
+    ----------
+    input : str or file-like object or compatible `astropy.io.fits` HDU object
+        If a string, the filename to read the table from. If a file object, or
+        a compatible HDU object, the object to extract the table from. The
+        following `astropy.io.fits` HDU objects can be used as input:
+        - :class:`~astropy.io.fits.hdu.table.TableHDU`
+        - :class:`~astropy.io.fits.hdu.table.BinTableHDU`
+        - :class:`~astropy.io.fits.hdu.table.GroupsHDU`
+        - :class:`~astropy.io.fits.hdu.hdulist.HDUList`
+    hdu : int or str, optional
+        The HDU to read the table from.
+    astropy_native : bool, optional
+        Read in FITS columns as native astropy objects where possible instead
+        of standard Table Column objects. Default is False.
+    memmap : bool, optional
+        Whether to use memory mapping, which accesses data on disk as needed. If
+        you are only accessing part of the data, this is often more efficient.
+        If you want to access all the values in the table, and you are able to
+        fit the table in memory, you may be better off leaving memory mapping
+        off. However, if your table would not fit in memory, you should set this
+        to `True`.
+    character_as_bytes : bool, optional
+        If `True`, string columns are stored as Numpy byte arrays (dtype ``S``)
+        and are converted on-the-fly to unicode strings when accessing
+        individual elements. If you need to use Numpy unicode arrays (dtype
+        ``U``) internally, you should set this to `False`, but note that this
+        will use more memory. If set to `False`, string columns will not be
+        memory-mapped even if ``memmap`` is `True`.
+    """
+
+    if isinstance(input, HDUList):
+
+        # Parse all table objects
+        tables = OrderedDict()
+        for ihdu, hdu_item in enumerate(input):
+            if isinstance(hdu_item, (TableHDU, BinTableHDU, GroupsHDU)):
+                tables[ihdu] = hdu_item
+
+        if len(tables) > 1:
+            if hdu is None:
+                warnings.warn("hdu= was not specified but multiple tables"
+                              " are present, reading in first available"
+                              " table (hdu={0})".format(first(tables)),
+                              AstropyUserWarning)
+                hdu = first(tables)
+
+            # hdu might not be an integer, so we first need to convert it
+            # to the correct HDU index
+            hdu = input.index_of(hdu)
+
+            if hdu in tables:
+                table = tables[hdu]
+            else:
+                raise ValueError("No table found in hdu={0}".format(hdu))
+
+        elif len(tables) == 1:
+            table = tables[first(tables)]
+        else:
+            raise ValueError("No table found")
+
+    elif isinstance(input, (TableHDU, BinTableHDU, GroupsHDU)):
+
+        table = input
+
+    else:
+
+        hdulist = fits_open(input, character_as_bytes=character_as_bytes,
+                            memmap=memmap)
+
+        try:
+            return read_table_fits(hdulist, hdu=hdu,
+                                   astropy_native=astropy_native)
+        finally:
+            hdulist.close()
+
+    # Check if table is masked
+    masked = any(col.null is not None for col in table.columns)
+
+    # TODO: in future, it may make more sense to do this column-by-column,
+    # rather than via the structured array.
+
+    # In the loop below we access the data using data[col.name] rather than
+    # col.array to make sure that the data is scaled correctly if needed.
+    data = table.data
+
+    columns = []
+    for col in data.columns:
+
+        # Set column data
+        if masked:
+            column = MaskedColumn(data=data[col.name], name=col.name, copy=False)
+            if col.null is not None:
+                column.set_fill_value(col.null)
+                column.mask[column.data == col.null] = True
+        else:
+            column = Column(data=data[col.name], name=col.name, copy=False)
+
+        # Copy over units
+        if col.unit is not None:
+            column.unit = u.Unit(col.unit, format='fits', parse_strict='silent')
+
+        # Copy over display format
+        if col.disp is not None:
+            column.format = _fortran_to_python_format(col.disp)
+
+        columns.append(column)
+
+    # Create Table object
+    t = Table(columns, masked=masked, copy=False)
+
+    # TODO: deal properly with unsigned integers
+
+    hdr = table.header
+    if astropy_native:
+        # Avoid circular imports, and also only import if necessary.
+        from .fitstime import fits_to_time
+        hdr = fits_to_time(hdr, t)
+
+    for key, value, comment in hdr.cards:
+
+        if key in ['COMMENT', 'HISTORY']:
+            # Convert to io.ascii format
+            if key == 'COMMENT':
+                key = 'comments'
+
+            if key in t.meta:
+                t.meta[key].append(value)
+            else:
+                t.meta[key] = [value]
+
+        elif key in t.meta:  # key is duplicate
+
+            if isinstance(t.meta[key], list):
+                t.meta[key].append(value)
+            else:
+                t.meta[key] = [t.meta[key], value]
+
+        elif is_column_keyword(key) or key in REMOVE_KEYWORDS:
+
+            pass
+
+        else:
+
+            t.meta[key] = value
+
+    # TODO: implement masking
+
+    # Decode any mixin columns that have been stored as standard Columns.
+    t = _decode_mixins(t)
+
+    return t
+
+
+def _encode_mixins(tbl):
+    """Encode a Table ``tbl`` that may have mixin columns to a Table with only
+    astropy Columns + appropriate meta-data to allow subsequent decoding.
+    """
+    # Determine if information will be lost without serializing meta.  This is hardcoded
+    # to the set difference between column info attributes and what FITS can store
+    # natively (name, dtype, unit).  See _get_col_attributes() in table/meta.py for where
+    # this comes from.
+    info_lost = any(any(getattr(col.info, attr, None) not in (None, {})
+                        for attr in ('description', 'meta'))
+                    for col in tbl.itercols())
+
+    # If PyYAML is not available then check to see if there are any mixin cols
+    # that *require* YAML serialization.  FITS already has support for Time,
+    # Quantity, so if those are the only mixins the proceed without doing the
+    # YAML bit, for backward compatibility (i.e. not requiring YAML to write
+    # Time or Quantity).  In this case other mixin column meta (e.g.
+    # description or meta) will be silently dropped, consistent with astropy <=
+    # 2.0 behavior.
+    try:
+        import yaml  # noqa
+    except ImportError:
+        for col in tbl.itercols():
+            if (has_info_class(col, MixinInfo) and
+                    col.__class__ not in (u.Quantity, Time)):
+                raise TypeError("cannot write type {} column '{}' "
+                                "to FITS without PyYAML installed."
+                                .format(col.__class__.__name__, col.info.name))
+        else:
+            if info_lost:
+                warnings.warn("table contains column(s) with defined 'format',"
+                              " 'description', or 'meta' info attributes. These"
+                              " will be dropped unless you install PyYAML.",
+                              AstropyUserWarning)
+            return tbl
+
+    # Convert the table to one with no mixins, only Column objects.  This adds
+    # meta data which is extracted with meta.get_yaml_from_table.  This ignores
+    # Time-subclass columns and leave them in the table so that the downstream
+    # FITS Time handling does the right thing.
+
+    with serialize_context_as('fits'):
+        encode_tbl = serialize.represent_mixins_as_columns(
+            tbl, exclude_classes=(Time,))
+
+    # If the encoded table is unchanged then there were no mixins.  But if there
+    # is column metadata (format, description, meta) that would be lost, then
+    # still go through the serialized columns machinery.
+    if encode_tbl is tbl and not info_lost:
+        return tbl
+
+    # Get the YAML serialization of information describing the table columns.
+    # This is re-using ECSV code that combined existing table.meta with with
+    # the extra __serialized_columns__ key.  For FITS the table.meta is handled
+    # by the native FITS connect code, so don't include that in the YAML
+    # output.
+    ser_col = '__serialized_columns__'
+
+    # encode_tbl might not have a __serialized_columns__ key if there were no mixins,
+    # but machinery below expects it to be available, so just make an empty dict.
+    encode_tbl.meta.setdefault(ser_col, {})
+
+    tbl_meta_copy = encode_tbl.meta.copy()
+    try:
+        encode_tbl.meta = {ser_col: encode_tbl.meta[ser_col]}
+        meta_yaml_lines = meta.get_yaml_from_table(encode_tbl)
+    finally:
+        encode_tbl.meta = tbl_meta_copy
+    del encode_tbl.meta[ser_col]
+
+    if 'comments' not in encode_tbl.meta:
+        encode_tbl.meta['comments'] = []
+    encode_tbl.meta['comments'].append('--BEGIN-ASTROPY-SERIALIZED-COLUMNS--')
+
+    for line in meta_yaml_lines:
+        if len(line) == 0:
+            lines = ['']
+        else:
+            # Split line into 70 character chunks for COMMENT cards
+            idxs = list(range(0, len(line) + 70, 70))
+            lines = [line[i0:i1] + '\\' for i0, i1 in zip(idxs[:-1], idxs[1:])]
+            lines[-1] = lines[-1][:-1]
+        encode_tbl.meta['comments'].extend(lines)
+
+    encode_tbl.meta['comments'].append('--END-ASTROPY-SERIALIZED-COLUMNS--')
+
+    return encode_tbl
+
+
+def write_table_fits(input, output, overwrite=False):
+    """
+    Write a Table object to a FITS file
+
+    Parameters
+    ----------
+    input : Table
+        The table to write out.
+    output : str
+        The filename to write the table to.
+    overwrite : bool
+        Whether to overwrite any existing file without warning.
+    """
+
+    # Encode any mixin columns into standard Columns.
+    input = _encode_mixins(input)
+
+    table_hdu = table_to_hdu(input, character_as_bytes=True)
+
+    # Check if output file already exists
+    if isinstance(output, str) and os.path.exists(output):
+        if overwrite:
+            os.remove(output)
+        else:
+            raise OSError("File exists: {0}".format(output))
+
+    table_hdu.writeto(output)
+
+
+io_registry.register_reader('fits', Table, read_table_fits)
+io_registry.register_writer('fits', Table, write_table_fits)
+io_registry.register_identifier('fits', Table, is_fits)

testbed/astropy__astropy/astropy/io/fits/convenience.py

@@ -0,0 +1,1086 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+"""
+Convenience functions
+=====================
+
+The functions in this module provide shortcuts for some of the most basic
+operations on FITS files, such as reading and updating the header.  They are
+included directly in the 'astropy.io.fits' namespace so that they can be used
+like::
+
+    astropy.io.fits.getheader(...)
+
+These functions are primarily for convenience when working with FITS files in
+the command-line interpreter.  If performing several operations on the same
+file, such as in a script, it is better to *not* use these functions, as each
+one must open and re-parse the file.  In such cases it is better to use
+:func:`astropy.io.fits.open` and work directly with the
+:class:`astropy.io.fits.HDUList` object and underlying HDU objects.
+
+Several of the convenience functions, such as `getheader` and `getdata` support
+special arguments for selecting which extension HDU to use when working with a
+multi-extension FITS file.  There are a few supported argument formats for
+selecting the extension.  See the documentation for `getdata` for an
+explanation of all the different formats.
+
+.. warning::
+    All arguments to convenience functions other than the filename that are
+    *not* for selecting the extension HDU should be passed in as keyword
+    arguments.  This is to avoid ambiguity and conflicts with the
+    extension arguments.  For example, to set NAXIS=1 on the Primary HDU:
+
+    Wrong::
+
+        astropy.io.fits.setval('myimage.fits', 'NAXIS', 1)
+
+    The above example will try to set the NAXIS value on the first extension
+    HDU to blank.  That is, the argument '1' is assumed to specify an extension
+    HDU.
+
+    Right::
+
+        astropy.io.fits.setval('myimage.fits', 'NAXIS', value=1)
+
+    This will set the NAXIS keyword to 1 on the primary HDU (the default).  To
+    specify the first extension HDU use::
+
+        astropy.io.fits.setval('myimage.fits', 'NAXIS', value=1, ext=1)
+
+    This complexity arises out of the attempt to simultaneously support
+    multiple argument formats that were used in past versions of PyFITS.
+    Unfortunately, it is not possible to support all formats without
+    introducing some ambiguity.  A future Astropy release may standardize
+    around a single format and officially deprecate the other formats.
+"""
+
+
+import operator
+import os
+import warnings
+
+import numpy as np
+
+from .diff import FITSDiff, HDUDiff
+from .file import FILE_MODES, _File
+from .hdu.base import _BaseHDU, _ValidHDU
+from .hdu.hdulist import fitsopen, HDUList
+from .hdu.image import PrimaryHDU, ImageHDU
+from .hdu.table import BinTableHDU
+from .header import Header
+from .util import fileobj_closed, fileobj_name, fileobj_mode, _is_int
+from astropy.utils.exceptions import AstropyUserWarning
+from astropy.utils.decorators import deprecated_renamed_argument
+
+
+__all__ = ['getheader', 'getdata', 'getval', 'setval', 'delval', 'writeto',
+           'append', 'update', 'info', 'tabledump', 'tableload',
+           'table_to_hdu', 'printdiff']
+
+
+def getheader(filename, *args, **kwargs):
+    """
+    Get the header from an extension of a FITS file.
+
+    Parameters
+    ----------
+    filename : file path, file object, or file like object
+        File to get header from.  If an opened file object, its mode
+        must be one of the following rb, rb+, or ab+).
+
+    ext, extname, extver
+        The rest of the arguments are for extension specification.  See the
+        `getdata` documentation for explanations/examples.
+
+    kwargs
+        Any additional keyword arguments to be passed to
+        `astropy.io.fits.open`.
+
+    Returns
+    -------
+    header : `Header` object
+    """
+
+    mode, closed = _get_file_mode(filename)
+    hdulist, extidx = _getext(filename, mode, *args, **kwargs)
+    try:
+        hdu = hdulist[extidx]
+        header = hdu.header
+    finally:
+        hdulist.close(closed=closed)
+
+    return header
+
+
+def getdata(filename, *args, header=None, lower=None, upper=None, view=None,
+            **kwargs):
+    """
+    Get the data from an extension of a FITS file (and optionally the
+    header).
+
+    Parameters
+    ----------
+    filename : file path, file object, or file like object
+        File to get data from.  If opened, mode must be one of the
+        following rb, rb+, or ab+.
+
+    ext
+        The rest of the arguments are for extension specification.
+        They are flexible and are best illustrated by examples.
+
+        No extra arguments implies the primary header::
+
+            getdata('in.fits')
+
+        By extension number::
+
+            getdata('in.fits', 0)      # the primary header
+            getdata('in.fits', 2)      # the second extension
+            getdata('in.fits', ext=2)  # the second extension
+
+        By name, i.e., ``EXTNAME`` value (if unique)::
+
+            getdata('in.fits', 'sci')
+            getdata('in.fits', extname='sci')  # equivalent
+
+        Note ``EXTNAME`` values are not case sensitive
+
+        By combination of ``EXTNAME`` and EXTVER`` as separate
+        arguments or as a tuple::
+
+            getdata('in.fits', 'sci', 2)  # EXTNAME='SCI' & EXTVER=2
+            getdata('in.fits', extname='sci', extver=2)  # equivalent
+            getdata('in.fits', ('sci', 2))  # equivalent
+
+        Ambiguous or conflicting specifications will raise an exception::
+
+            getdata('in.fits', ext=('sci',1), extname='err', extver=2)
+
+    header : bool, optional
+        If `True`, return the data and the header of the specified HDU as a
+        tuple.
+
+    lower, upper : bool, optional
+        If ``lower`` or ``upper`` are `True`, the field names in the
+        returned data object will be converted to lower or upper case,
+        respectively.
+
+    view : ndarray, optional
+        When given, the data will be returned wrapped in the given ndarray
+        subclass by calling::
+
+           data.view(view)
+
+    kwargs
+        Any additional keyword arguments to be passed to
+        `astropy.io.fits.open`.
+
+    Returns
+    -------
+    array : array, record array or groups data object
+        Type depends on the type of the extension being referenced.
+
+        If the optional keyword ``header`` is set to `True`, this
+        function will return a (``data``, ``header``) tuple.
+    """
+
+    mode, closed = _get_file_mode(filename)
+
+    hdulist, extidx = _getext(filename, mode, *args, **kwargs)
+    try:
+        hdu = hdulist[extidx]
+        data = hdu.data
+        if data is None and extidx == 0:
+            try:
+                hdu = hdulist[1]
+                data = hdu.data
+            except IndexError:
+                raise IndexError('No data in this HDU.')
+        if data is None:
+            raise IndexError('No data in this HDU.')
+        if header:
+            hdr = hdu.header
+    finally:
+        hdulist.close(closed=closed)
+
+    # Change case of names if requested
+    trans = None
+    if lower:
+        trans = operator.methodcaller('lower')
+    elif upper:
+        trans = operator.methodcaller('upper')
+    if trans:
+        if data.dtype.names is None:
+            # this data does not have fields
+            return
+        if data.dtype.descr[0][0] == '':
+            # this data does not have fields
+            return
+        data.dtype.names = [trans(n) for n in data.dtype.names]
+
+    # allow different views into the underlying ndarray.  Keep the original
+    # view just in case there is a problem
+    if isinstance(view, type) and issubclass(view, np.ndarray):
+        data = data.view(view)
+
+    if header:
+        return data, hdr
+    else:
+        return data
+
+
+def getval(filename, keyword, *args, **kwargs):
+    """
+    Get a keyword's value from a header in a FITS file.
+
+    Parameters
+    ----------
+    filename : file path, file object, or file like object
+        Name of the FITS file, or file object (if opened, mode must be
+        one of the following rb, rb+, or ab+).
+
+    keyword : str
+        Keyword name
+
+    ext, extname, extver
+        The rest of the arguments are for extension specification.
+        See `getdata` for explanations/examples.
+
+    kwargs
+        Any additional keyword arguments to be passed to
+        `astropy.io.fits.open`.
+        *Note:* This function automatically specifies ``do_not_scale_image_data
+        = True`` when opening the file so that values can be retrieved from the
+        unmodified header.
+
+    Returns
+    -------
+    keyword value : str, int, or float
+    """
+
+    if 'do_not_scale_image_data' not in kwargs:
+        kwargs['do_not_scale_image_data'] = True
+
+    hdr = getheader(filename, *args, **kwargs)
+    return hdr[keyword]
+
+
+def setval(filename, keyword, *args, value=None, comment=None, before=None,
+           after=None, savecomment=False, **kwargs):
+    """
+    Set a keyword's value from a header in a FITS file.
+
+    If the keyword already exists, it's value/comment will be updated.
+    If it does not exist, a new card will be created and it will be
+    placed before or after the specified location.  If no ``before`` or
+    ``after`` is specified, it will be appended at the end.
+
+    When updating more than one keyword in a file, this convenience
+    function is a much less efficient approach compared with opening
+    the file for update, modifying the header, and closing the file.
+
+    Parameters
+    ----------
+    filename : file path, file object, or file like object
+        Name of the FITS file, or file object If opened, mode must be update
+        (rb+).  An opened file object or `~gzip.GzipFile` object will be closed
+        upon return.
+
+    keyword : str
+        Keyword name
+
+    value : str, int, float, optional
+        Keyword value (default: `None`, meaning don't modify)
+
+    comment : str, optional
+        Keyword comment, (default: `None`, meaning don't modify)
+
+    before : str, int, optional
+        Name of the keyword, or index of the card before which the new card
+        will be placed.  The argument ``before`` takes precedence over
+        ``after`` if both are specified (default: `None`).
+
+    after : str, int, optional
+        Name of the keyword, or index of the card after which the new card will
+        be placed. (default: `None`).
+
+    savecomment : bool, optional
+        When `True`, preserve the current comment for an existing keyword.  The
+        argument ``savecomment`` takes precedence over ``comment`` if both
+        specified.  If ``comment`` is not specified then the current comment
+        will automatically be preserved  (default: `False`).
+
+    ext, extname, extver
+        The rest of the arguments are for extension specification.
+        See `getdata` for explanations/examples.
+
+    kwargs
+        Any additional keyword arguments to be passed to
+        `astropy.io.fits.open`.
+        *Note:* This function automatically specifies ``do_not_scale_image_data
+        = True`` when opening the file so that values can be retrieved from the
+        unmodified header.
+    """
+
+    if 'do_not_scale_image_data' not in kwargs:
+        kwargs['do_not_scale_image_data'] = True
+
+    closed = fileobj_closed(filename)
+    hdulist, extidx = _getext(filename, 'update', *args, **kwargs)
+    try:
+        if keyword in hdulist[extidx].header and savecomment:
+            comment = None
+        hdulist[extidx].header.set(keyword, value, comment, before, after)
+    finally:
+        hdulist.close(closed=closed)
+
+
+def delval(filename, keyword, *args, **kwargs):
+    """
+    Delete all instances of keyword from a header in a FITS file.
+
+    Parameters
+    ----------
+
+    filename : file path, file object, or file like object
+        Name of the FITS file, or file object If opened, mode must be update
+        (rb+).  An opened file object or `~gzip.GzipFile` object will be closed
+        upon return.
+
+    keyword : str, int
+        Keyword name or index
+
+    ext, extname, extver
+        The rest of the arguments are for extension specification.
+        See `getdata` for explanations/examples.
+
+    kwargs
+        Any additional keyword arguments to be passed to
+        `astropy.io.fits.open`.
+        *Note:* This function automatically specifies ``do_not_scale_image_data
+        = True`` when opening the file so that values can be retrieved from the
+        unmodified header.
+    """
+
+    if 'do_not_scale_image_data' not in kwargs:
+        kwargs['do_not_scale_image_data'] = True
+
+    closed = fileobj_closed(filename)
+    hdulist, extidx = _getext(filename, 'update', *args, **kwargs)
+    try:
+        del hdulist[extidx].header[keyword]
+    finally:
+        hdulist.close(closed=closed)
+
+
+@deprecated_renamed_argument('clobber', 'overwrite', '2.0')
+def writeto(filename, data, header=None, output_verify='exception',
+            overwrite=False, checksum=False):
+    """
+    Create a new FITS file using the supplied data/header.
+
+    Parameters
+    ----------
+    filename : file path, file object, or file like object
+        File to write to.  If opened, must be opened in a writeable binary
+        mode such as 'wb' or 'ab+'.
+
+    data : array, record array, or groups data object
+        data to write to the new file
+
+    header : `Header` object, optional
+        the header associated with ``data``. If `None`, a header
+        of the appropriate type is created for the supplied data. This
+        argument is optional.
+
+    output_verify : str
+        Output verification option.  Must be one of ``"fix"``, ``"silentfix"``,
+        ``"ignore"``, ``"warn"``, or ``"exception"``.  May also be any
+        combination of ``"fix"`` or ``"silentfix"`` with ``"+ignore"``,
+        ``+warn``, or ``+exception" (e.g. ``"fix+warn"``).  See :ref:`verify`
+        for more info.
+
+    overwrite : bool, optional
+        If ``True``, overwrite the output file if it exists. Raises an
+        ``OSError`` if ``False`` and the output file exists. Default is
+        ``False``.
+
+        .. versionchanged:: 1.3
+           ``overwrite`` replaces the deprecated ``clobber`` argument.
+
+    checksum : bool, optional
+        If `True`, adds both ``DATASUM`` and ``CHECKSUM`` cards to the
+        headers of all HDU's written to the file.
+    """
+
+    hdu = _makehdu(data, header)
+    if hdu.is_image and not isinstance(hdu, PrimaryHDU):
+        hdu = PrimaryHDU(data, header=header)
+    hdu.writeto(filename, overwrite=overwrite, output_verify=output_verify,
+                checksum=checksum)
+
+
+def table_to_hdu(table, character_as_bytes=False):
+    """
+    Convert an `~astropy.table.Table` object to a FITS
+    `~astropy.io.fits.BinTableHDU`.
+
+    Parameters
+    ----------
+    table : astropy.table.Table
+        The table to convert.
+    character_as_bytes : bool
+        Whether to return bytes for string columns when accessed from the HDU.
+        By default this is `False` and (unicode) strings are returned, but for
+        large tables this may use up a lot of memory.
+
+    Returns
+    -------
+    table_hdu : `~astropy.io.fits.BinTableHDU`
+        The FITS binary table HDU.
+    """
+    # Avoid circular imports
+    from .connect import is_column_keyword, REMOVE_KEYWORDS
+    from .column import python_to_tdisp
+
+    # Header to store Time related metadata
+    hdr = None
+
+    # Not all tables with mixin columns are supported
+    if table.has_mixin_columns:
+        # Import is done here, in order to avoid it at build time as erfa is not
+        # yet available then.
+        from astropy.table.column import BaseColumn
+        from astropy.time import Time
+        from astropy.units import Quantity
+        from .fitstime import time_to_fits
+
+        # Only those columns which are instances of BaseColumn, Quantity or Time can
+        # be written
+        unsupported_cols = table.columns.not_isinstance((BaseColumn, Quantity, Time))
+        if unsupported_cols:
+            unsupported_names = [col.info.name for col in unsupported_cols]
+            raise ValueError('cannot write table with mixin column(s) {0}'
+                         .format(unsupported_names))
+
+        time_cols = table.columns.isinstance(Time)
+        if time_cols:
+            table, hdr = time_to_fits(table)
+
+    # Create a new HDU object
+    if table.masked:
+        # float column's default mask value needs to be Nan
+        for column in table.columns.values():
+            fill_value = column.get_fill_value()
+            if column.dtype.kind == 'f' and np.allclose(fill_value, 1e20):
+                column.set_fill_value(np.nan)
+
+        # TODO: it might be better to construct the FITS table directly from
+        # the Table columns, rather than go via a structured array.
+        table_hdu = BinTableHDU.from_columns(np.array(table.filled()), header=hdr, character_as_bytes=True)
+        for col in table_hdu.columns:
+            # Binary FITS tables support TNULL *only* for integer data columns
+            # TODO: Determine a schema for handling non-integer masked columns
+            # in FITS (if at all possible)
+            int_formats = ('B', 'I', 'J', 'K')
+            if not (col.format in int_formats or
+                    col.format.p_format in int_formats):
+                continue
+
+            # The astype is necessary because if the string column is less
+            # than one character, the fill value will be N/A by default which
+            # is too long, and so no values will get masked.
+            fill_value = table[col.name].get_fill_value()
+
+            col.null = fill_value.astype(table[col.name].dtype)
+    else:
+        table_hdu = BinTableHDU.from_columns(np.array(table.filled()), header=hdr, character_as_bytes=character_as_bytes)
+
+    # Set units and format display for output HDU
+    for col in table_hdu.columns:
+
+        if table[col.name].info.format is not None:
+            # check for boolean types, special format case
+            logical = table[col.name].info.dtype == bool
+
+            tdisp_format = python_to_tdisp(table[col.name].info.format,
+                                           logical_dtype=logical)
+            if tdisp_format is not None:
+                col.disp = tdisp_format
+
+        unit = table[col.name].unit
+        if unit is not None:
+            # Local imports to avoid importing units when it is not required,
+            # e.g. for command-line scripts
+            from astropy.units import Unit
+            from astropy.units.format.fits import UnitScaleError
+            try:
+                col.unit = unit.to_string(format='fits')
+            except UnitScaleError:
+                scale = unit.scale
+                raise UnitScaleError(
+                    "The column '{0}' could not be stored in FITS format "
+                    "because it has a scale '({1})' that "
+                    "is not recognized by the FITS standard. Either scale "
+                    "the data or change the units.".format(col.name, str(scale)))
+            except ValueError:
+                warnings.warn(
+                    "The unit '{0}' could not be saved to FITS format".format(
+                        unit.to_string()), AstropyUserWarning)
+
+            # Try creating a Unit to issue a warning if the unit is not FITS compliant
+            Unit(col.unit, format='fits', parse_strict='warn')
+
+    # Column-specific override keywords for coordinate columns
+    coord_meta = table.meta.pop('__coordinate_columns__', {})
+    for col_name, col_info in coord_meta.items():
+        col = table_hdu.columns[col_name]
+        # Set the column coordinate attributes from data saved earlier.
+        # Note: have to set all three, even if we have no data.
+        for attr in 'coord_type', 'coord_unit', 'time_ref_pos':
+            setattr(col, attr, col_info.get(attr, None))
+
+    for key, value in table.meta.items():
+        if is_column_keyword(key.upper()) or key.upper() in REMOVE_KEYWORDS:
+            warnings.warn(
+                "Meta-data keyword {0} will be ignored since it conflicts "
+                "with a FITS reserved keyword".format(key), AstropyUserWarning)
+
+        # Convert to FITS format
+        if key == 'comments':
+            key = 'comment'
+
+        if isinstance(value, list):
+            for item in value:
+                try:
+                    table_hdu.header.append((key, item))
+                except ValueError:
+                    warnings.warn(
+                        "Attribute `{0}` of type {1} cannot be added to "
+                        "FITS Header - skipping".format(key, type(value)),
+                        AstropyUserWarning)
+        else:
+            try:
+                table_hdu.header[key] = value
+            except ValueError:
+                warnings.warn(
+                    "Attribute `{0}` of type {1} cannot be added to FITS "
+                    "Header - skipping".format(key, type(value)),
+                    AstropyUserWarning)
+    return table_hdu
+
+
+def append(filename, data, header=None, checksum=False, verify=True, **kwargs):
+    """
+    Append the header/data to FITS file if filename exists, create if not.
+
+    If only ``data`` is supplied, a minimal header is created.
+
+    Parameters
+    ----------
+    filename : file path, file object, or file like object
+        File to write to.  If opened, must be opened for update (rb+) unless it
+        is a new file, then it must be opened for append (ab+).  A file or
+        `~gzip.GzipFile` object opened for update will be closed after return.
+
+    data : array, table, or group data object
+        the new data used for appending
+
+    header : `Header` object, optional
+        The header associated with ``data``.  If `None`, an appropriate header
+        will be created for the data object supplied.
+
+    checksum : bool, optional
+        When `True` adds both ``DATASUM`` and ``CHECKSUM`` cards to the header
+        of the HDU when written to the file.
+
+    verify : bool, optional
+        When `True`, the existing FITS file will be read in to verify it for
+        correctness before appending.  When `False`, content is simply appended
+        to the end of the file.  Setting ``verify`` to `False` can be much
+        faster.
+
+    kwargs
+        Additional arguments are passed to:
+
+        - `~astropy.io.fits.writeto` if the file does not exist or is empty.
+          In this case ``output_verify`` is the only possible argument.
+        - `~astropy.io.fits.open` if ``verify`` is True or if ``filename``
+          is a file object.
+        - Otherwise no additional arguments can be used.
+
+    """
+    name, closed, noexist_or_empty = _stat_filename_or_fileobj(filename)
+
+    if noexist_or_empty:
+        #
+        # The input file or file like object either doesn't exits or is
+        # empty.  Use the writeto convenience function to write the
+        # output to the empty object.
+        #
+        writeto(filename, data, header, checksum=checksum, **kwargs)
+    else:
+        hdu = _makehdu(data, header)
+
+        if isinstance(hdu, PrimaryHDU):
+            hdu = ImageHDU(data, header)
+
+        if verify or not closed:
+            f = fitsopen(filename, mode='append', **kwargs)
+            try:
+                f.append(hdu)
+
+                # Set a flag in the HDU so that only this HDU gets a checksum
+                # when writing the file.
+                hdu._output_checksum = checksum
+            finally:
+                f.close(closed=closed)
+        else:
+            f = _File(filename, mode='append')
+            try:
+                hdu._output_checksum = checksum
+                hdu._writeto(f)
+            finally:
+                f.close()
+
+
+def update(filename, data, *args, **kwargs):
+    """
+    Update the specified extension with the input data/header.
+
+    Parameters
+    ----------
+    filename : file path, file object, or file like object
+        File to update.  If opened, mode must be update (rb+).  An opened file
+        object or `~gzip.GzipFile` object will be closed upon return.
+
+    data : array, table, or group data object
+        the new data used for updating
+
+    header : `Header` object, optional
+        The header associated with ``data``.  If `None`, an appropriate header
+        will be created for the data object supplied.
+
+    ext, extname, extver
+        The rest of the arguments are flexible: the 3rd argument can be the
+        header associated with the data.  If the 3rd argument is not a
+        `Header`, it (and other positional arguments) are assumed to be the
+        extension specification(s).  Header and extension specs can also be
+        keyword arguments.  For example::
+
+            update(file, dat, hdr, 'sci')  # update the 'sci' extension
+            update(file, dat, 3)  # update the 3rd extension
+            update(file, dat, hdr, 3)  # update the 3rd extension
+            update(file, dat, 'sci', 2)  # update the 2nd SCI extension
+            update(file, dat, 3, header=hdr)  # update the 3rd extension
+            update(file, dat, header=hdr, ext=5)  # update the 5th extension
+
+    kwargs
+        Any additional keyword arguments to be passed to
+        `astropy.io.fits.open`.
+    """
+
+    # The arguments to this function are a bit trickier to deal with than others
+    # in this module, since the documentation has promised that the header
+    # argument can be an optional positional argument.
+    if args and isinstance(args[0], Header):
+        header = args[0]
+        args = args[1:]
+    else:
+        header = None
+    # The header can also be a keyword argument--if both are provided the
+    # keyword takes precedence
+    header = kwargs.pop('header', header)
+
+    new_hdu = _makehdu(data, header)
+
+    closed = fileobj_closed(filename)
+
+    hdulist, _ext = _getext(filename, 'update', *args, **kwargs)
+    try:
+        hdulist[_ext] = new_hdu
+    finally:
+        hdulist.close(closed=closed)
+
+
+def info(filename, output=None, **kwargs):
+    """
+    Print the summary information on a FITS file.
+
+    This includes the name, type, length of header, data shape and type
+    for each extension.
+
+    Parameters
+    ----------
+    filename : file path, file object, or file like object
+        FITS file to obtain info from.  If opened, mode must be one of
+        the following: rb, rb+, or ab+ (i.e. the file must be readable).
+
+    output : file, bool, optional
+        A file-like object to write the output to.  If ``False``, does not
+        output to a file and instead returns a list of tuples representing the
+        HDU info.  Writes to ``sys.stdout`` by default.
+
+    kwargs
+        Any additional keyword arguments to be passed to
+        `astropy.io.fits.open`.
+        *Note:* This function sets ``ignore_missing_end=True`` by default.
+    """
+
+    mode, closed = _get_file_mode(filename, default='readonly')
+    # Set the default value for the ignore_missing_end parameter
+    if 'ignore_missing_end' not in kwargs:
+        kwargs['ignore_missing_end'] = True
+
+    f = fitsopen(filename, mode=mode, **kwargs)
+    try:
+        ret = f.info(output=output)
+    finally:
+        if closed:
+            f.close()
+
+    return ret
+
+
+def printdiff(inputa, inputb, *args, **kwargs):
+    """
+    Compare two parts of a FITS file, including entire FITS files,
+    FITS `HDUList` objects and FITS ``HDU`` objects.
+
+    Parameters
+    ----------
+    inputa : str, `HDUList` object, or ``HDU`` object
+        The filename of a FITS file, `HDUList`, or ``HDU``
+        object to compare to ``inputb``.
+
+    inputb : str, `HDUList` object, or ``HDU`` object
+        The filename of a FITS file, `HDUList`, or ``HDU``
+        object to compare to ``inputa``.
+
+    ext, extname, extver
+        Additional positional arguments are for extension specification if your
+        inputs are string filenames (will not work if
+        ``inputa`` and ``inputb`` are ``HDU`` objects or `HDUList` objects).
+        They are flexible and are best illustrated by examples.  In addition
+        to using these arguments positionally you can directly call the
+        keyword parameters ``ext``, ``extname``.
+
+        By extension number::
+
+            printdiff('inA.fits', 'inB.fits', 0)      # the primary HDU
+            printdiff('inA.fits', 'inB.fits', 2)      # the second extension
+            printdiff('inA.fits', 'inB.fits', ext=2)  # the second extension
+
+        By name, i.e., ``EXTNAME`` value (if unique). ``EXTNAME`` values are
+        not case sensitive:
+
+            printdiff('inA.fits', 'inB.fits', 'sci')
+            printdiff('inA.fits', 'inB.fits', extname='sci')  # equivalent
+
+        By combination of ``EXTNAME`` and ``EXTVER`` as separate
+        arguments or as a tuple::
+
+            printdiff('inA.fits', 'inB.fits', 'sci', 2)    # EXTNAME='SCI'
+                                                           # & EXTVER=2
+            printdiff('inA.fits', 'inB.fits', extname='sci', extver=2)
+                                                           # equivalent
+            printdiff('inA.fits', 'inB.fits', ('sci', 2))  # equivalent
+
+        Ambiguous or conflicting specifications will raise an exception::
+
+            printdiff('inA.fits', 'inB.fits',
+                      ext=('sci', 1), extname='err', extver=2)
+
+    kwargs
+        Any additional keyword arguments to be passed to
+        `~astropy.io.fits.FITSDiff`.
+
+    Notes
+    -----
+    The primary use for the `printdiff` function is to allow quick print out
+    of a FITS difference report and will write to ``sys.stdout``.
+    To save the diff report to a file please use `~astropy.io.fits.FITSDiff`
+    directly.
+    """
+
+    # Pop extension keywords
+    extension = {key: kwargs.pop(key) for key in ['ext', 'extname', 'extver']
+                 if key in kwargs}
+    has_extensions = args or extension
+
+    if isinstance(inputa, str) and has_extensions:
+        # Use handy _getext to interpret any ext keywords, but
+        # will need to close a if  fails
+        modea, closeda = _get_file_mode(inputa)
+        modeb, closedb = _get_file_mode(inputb)
+
+        hdulista, extidxa = _getext(inputa, modea, *args, **extension)
+        # Have to close a if b doesn't make it
+        try:
+            hdulistb, extidxb = _getext(inputb, modeb, *args, **extension)
+        except Exception:
+            hdulista.close(closed=closeda)
+            raise
+
+        try:
+            hdua = hdulista[extidxa]
+            hdub = hdulistb[extidxb]
+            # See below print for note
+            print(HDUDiff(hdua, hdub, **kwargs).report())
+
+        finally:
+            hdulista.close(closed=closeda)
+            hdulistb.close(closed=closedb)
+
+    # If input is not a string, can feed HDU objects or HDUList directly,
+    # but can't currently handle extensions
+    elif isinstance(inputa, _ValidHDU) and has_extensions:
+        raise ValueError("Cannot use extension keywords when providing an "
+                         "HDU object.")
+
+    elif isinstance(inputa, _ValidHDU) and not has_extensions:
+        print(HDUDiff(inputa, inputb, **kwargs).report())
+
+    elif isinstance(inputa, HDUList) and has_extensions:
+        raise NotImplementedError("Extension specification with HDUList "
+                                  "objects not implemented.")
+
+    # This function is EXCLUSIVELY for printing the diff report to screen
+    # in a one-liner call, hence the use of print instead of logging
+    else:
+        print(FITSDiff(inputa, inputb, **kwargs).report())
+
+
+@deprecated_renamed_argument('clobber', 'overwrite', '2.0')
+def tabledump(filename, datafile=None, cdfile=None, hfile=None, ext=1,
+              overwrite=False):
+    """
+    Dump a table HDU to a file in ASCII format.  The table may be
+    dumped in three separate files, one containing column definitions,
+    one containing header parameters, and one for table data.
+
+    Parameters
+    ----------
+    filename : file path, file object or file-like object
+        Input fits file.
+
+    datafile : file path, file object or file-like object, optional
+        Output data file.  The default is the root name of the input
+        fits file appended with an underscore, followed by the
+        extension number (ext), followed by the extension ``.txt``.
+
+    cdfile : file path, file object or file-like object, optional
+        Output column definitions file.  The default is `None`,
+        no column definitions output is produced.
+
+    hfile : file path, file object or file-like object, optional
+        Output header parameters file.  The default is `None`,
+        no header parameters output is produced.
+
+    ext : int
+        The number of the extension containing the table HDU to be
+        dumped.
+
+    overwrite : bool, optional
+        If ``True``, overwrite the output file if it exists. Raises an
+        ``OSError`` if ``False`` and the output file exists. Default is
+        ``False``.
+
+        .. versionchanged:: 1.3
+           ``overwrite`` replaces the deprecated ``clobber`` argument.
+
+    Notes
+    -----
+    The primary use for the `tabledump` function is to allow editing in a
+    standard text editor of the table data and parameters.  The
+    `tableload` function can be used to reassemble the table from the
+    three ASCII files.
+    """
+
+    # allow file object to already be opened in any of the valid modes
+    # and leave the file in the same state (opened or closed) as when
+    # the function was called
+
+    mode, closed = _get_file_mode(filename, default='readonly')
+    f = fitsopen(filename, mode=mode)
+
+    # Create the default data file name if one was not provided
+    try:
+        if not datafile:
+            root, tail = os.path.splitext(f._file.name)
+            datafile = root + '_' + repr(ext) + '.txt'
+
+        # Dump the data from the HDU to the files
+        f[ext].dump(datafile, cdfile, hfile, overwrite)
+    finally:
+        if closed:
+            f.close()
+
+
+if isinstance(tabledump.__doc__, str):
+    tabledump.__doc__ += BinTableHDU._tdump_file_format.replace('\n', '\n    ')
+
+
+def tableload(datafile, cdfile, hfile=None):
+    """
+    Create a table from the input ASCII files.  The input is from up
+    to three separate files, one containing column definitions, one
+    containing header parameters, and one containing column data.  The
+    header parameters file is not required.  When the header
+    parameters file is absent a minimal header is constructed.
+
+    Parameters
+    ----------
+    datafile : file path, file object or file-like object
+        Input data file containing the table data in ASCII format.
+
+    cdfile : file path, file object or file-like object
+        Input column definition file containing the names, formats,
+        display formats, physical units, multidimensional array
+        dimensions, undefined values, scale factors, and offsets
+        associated with the columns in the table.
+
+    hfile : file path, file object or file-like object, optional
+        Input parameter definition file containing the header
+        parameter definitions to be associated with the table.
+        If `None`, a minimal header is constructed.
+
+    Notes
+    -----
+    The primary use for the `tableload` function is to allow the input of
+    ASCII data that was edited in a standard text editor of the table
+    data and parameters.  The tabledump function can be used to create the
+    initial ASCII files.
+    """
+
+    return BinTableHDU.load(datafile, cdfile, hfile, replace=True)
+
+
+if isinstance(tableload.__doc__, str):
+    tableload.__doc__ += BinTableHDU._tdump_file_format.replace('\n', '\n    ')
+
+
+def _getext(filename, mode, *args, ext=None, extname=None, extver=None,
+            **kwargs):
+    """
+    Open the input file, return the `HDUList` and the extension.
+
+    This supports several different styles of extension selection.  See the
+    :func:`getdata()` documentation for the different possibilities.
+    """
+
+    err_msg = ('Redundant/conflicting extension arguments(s): {}'.format(
+            {'args': args, 'ext': ext, 'extname': extname,
+             'extver': extver}))
+
+    # This code would be much simpler if just one way of specifying an
+    # extension were picked.  But now we need to support all possible ways for
+    # the time being.
+    if len(args) == 1:
+        # Must be either an extension number, an extension name, or an
+        # (extname, extver) tuple
+        if _is_int(args[0]) or (isinstance(ext, tuple) and len(ext) == 2):
+            if ext is not None or extname is not None or extver is not None:
+                raise TypeError(err_msg)
+            ext = args[0]
+        elif isinstance(args[0], str):
+            # The first arg is an extension name; it could still be valid
+            # to provide an extver kwarg
+            if ext is not None or extname is not None:
+                raise TypeError(err_msg)
+            extname = args[0]
+        else:
+            # Take whatever we have as the ext argument; we'll validate it
+            # below
+            ext = args[0]
+    elif len(args) == 2:
+        # Must be an extname and extver
+        if ext is not None or extname is not None or extver is not None:
+            raise TypeError(err_msg)
+        extname = args[0]
+        extver = args[1]
+    elif len(args) > 2:
+        raise TypeError('Too many positional arguments.')
+
+    if (ext is not None and
+            not (_is_int(ext) or
+                 (isinstance(ext, tuple) and len(ext) == 2 and
+                  isinstance(ext[0], str) and _is_int(ext[1])))):
+        raise ValueError(
+            'The ext keyword must be either an extension number '
+            '(zero-indexed) or a (extname, extver) tuple.')
+    if extname is not None and not isinstance(extname, str):
+        raise ValueError('The extname argument must be a string.')
+    if extver is not None and not _is_int(extver):
+        raise ValueError('The extver argument must be an integer.')
+
+    if ext is None and extname is None and extver is None:
+        ext = 0
+    elif ext is not None and (extname is not None or extver is not None):
+        raise TypeError(err_msg)
+    elif extname:
+        if extver:
+            ext = (extname, extver)
+        else:
+            ext = (extname, 1)
+    elif extver and extname is None:
+        raise TypeError('extver alone cannot specify an extension.')
+
+    hdulist = fitsopen(filename, mode=mode, **kwargs)
+
+    return hdulist, ext
+
+
+def _makehdu(data, header):
+    if header is None:
+        header = Header()
+    hdu = _BaseHDU._from_data(data, header)
+    if hdu.__class__ in (_BaseHDU, _ValidHDU):
+        # The HDU type was unrecognized, possibly due to a
+        # nonexistent/incomplete header
+        if ((isinstance(data, np.ndarray) and data.dtype.fields is not None) or
+                isinstance(data, np.recarray)):
+            hdu = BinTableHDU(data, header=header)
+        elif isinstance(data, np.ndarray):
+            hdu = ImageHDU(data, header=header)
+        else:
+            raise KeyError('Data must be a numpy array.')
+    return hdu
+
+
+def _stat_filename_or_fileobj(filename):
+    closed = fileobj_closed(filename)
+    name = fileobj_name(filename) or ''
+
+    try:
+        loc = filename.tell()
+    except AttributeError:
+        loc = 0
+
+    noexist_or_empty = ((name and
+                         (not os.path.exists(name) or
+                          (os.path.getsize(name) == 0)))
+                         or (not name and loc == 0))
+
+    return name, closed, noexist_or_empty
+
+
+def _get_file_mode(filename, default='readonly'):
+    """
+    Allow file object to already be opened in any of the valid modes and
+    and leave the file in the same state (opened or closed) as when
+    the function was called.
+    """
+
+    mode = default
+    closed = fileobj_closed(filename)
+
+    fmode = fileobj_mode(filename)
+    if fmode is not None:
+        mode = FILE_MODES.get(fmode)
+        if mode is None:
+            raise OSError(
+                "File mode of the input file object ({!r}) cannot be used to "
+                "read/write FITS files.".format(fmode))
+
+    return mode, closed

testbed/astropy__astropy/astropy/io/fits/diff.py

@@ -0,0 +1,1512 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+"""
+Facilities for diffing two FITS files.  Includes objects for diffing entire
+FITS files, individual HDUs, FITS headers, or just FITS data.
+
+Used to implement the fitsdiff program.
+"""
+import fnmatch
+import glob
+import io
+import operator
+import os.path
+import textwrap
+import warnings
+
+from collections import defaultdict
+from inspect import signature
+from itertools import islice
+
+import numpy as np
+
+from astropy import __version__
+
+from .card import Card, BLANK_CARD
+from .header import Header
+from astropy.utils.decorators import deprecated_renamed_argument
+# HDUList is used in one of the doctests
+from .hdu.hdulist import fitsopen, HDUList  # pylint: disable=W0611
+from .hdu.table import _TableLikeHDU
+from astropy.utils.exceptions import AstropyDeprecationWarning
+from astropy.utils.diff import (report_diff_values, fixed_width_indent,
+                           where_not_allclose, diff_values)
+
+__all__ = ['FITSDiff', 'HDUDiff', 'HeaderDiff', 'ImageDataDiff', 'RawDataDiff',
+           'TableDataDiff']
+
+# Column attributes of interest for comparison
+_COL_ATTRS = [('unit', 'units'), ('null', 'null values'),
+              ('bscale', 'bscales'), ('bzero', 'bzeros'),
+              ('disp', 'display formats'), ('dim', 'dimensions')]
+
+
+class _BaseDiff:
+    """
+    Base class for all FITS diff objects.
+
+    When instantiating a FITS diff object, the first two arguments are always
+    the two objects to diff (two FITS files, two FITS headers, etc.).
+    Instantiating a ``_BaseDiff`` also causes the diff itself to be executed.
+    The returned ``_BaseDiff`` instance has a number of attribute that describe
+    the results of the diff operation.
+
+    The most basic attribute, present on all ``_BaseDiff`` instances, is
+    ``.identical`` which is `True` if the two objects being compared are
+    identical according to the diff method for objects of that type.
+    """
+
+    def __init__(self, a, b):
+        """
+        The ``_BaseDiff`` class does not implement a ``_diff`` method and
+        should not be instantiated directly. Instead instantiate the
+        appropriate subclass of ``_BaseDiff`` for the objects being compared
+        (for example, use `HeaderDiff` to compare two `Header` objects.
+        """
+
+        self.a = a
+        self.b = b
+
+        # For internal use in report output
+        self._fileobj = None
+        self._indent = 0
+
+        self._diff()
+
+    def __bool__(self):
+        """
+        A ``_BaseDiff`` object acts as `True` in a boolean context if the two
+        objects compared are identical.  Otherwise it acts as `False`.
+        """
+
+        return not self.identical
+
+    @classmethod
+    def fromdiff(cls, other, a, b):
+        """
+        Returns a new Diff object of a specific subclass from an existing diff
+        object, passing on the values for any arguments they share in common
+        (such as ignore_keywords).
+
+        For example::
+
+            >>> from astropy.io import fits
+            >>> hdul1, hdul2 = fits.HDUList(), fits.HDUList()
+            >>> headera, headerb = fits.Header(), fits.Header()
+            >>> fd = fits.FITSDiff(hdul1, hdul2, ignore_keywords=['*'])
+            >>> hd = fits.HeaderDiff.fromdiff(fd, headera, headerb)
+            >>> list(hd.ignore_keywords)
+            ['*']
+        """
+
+        sig = signature(cls.__init__)
+        # The first 3 arguments of any Diff initializer are self, a, and b.
+        kwargs = {}
+        for arg in list(sig.parameters.keys())[3:]:
+            if hasattr(other, arg):
+                kwargs[arg] = getattr(other, arg)
+
+        return cls(a, b, **kwargs)
+
+    @property
+    def identical(self):
+        """
+        `True` if all the ``.diff_*`` attributes on this diff instance are
+        empty, implying that no differences were found.
+
+        Any subclass of ``_BaseDiff`` must have at least one ``.diff_*``
+        attribute, which contains a non-empty value if and only if some
+        difference was found between the two objects being compared.
+        """
+
+        return not any(getattr(self, attr) for attr in self.__dict__
+                       if attr.startswith('diff_'))
+
+    @deprecated_renamed_argument('clobber', 'overwrite', '2.0')
+    def report(self, fileobj=None, indent=0, overwrite=False):
+        """
+        Generates a text report on the differences (if any) between two
+        objects, and either returns it as a string or writes it to a file-like
+        object.
+
+        Parameters
+        ----------
+        fileobj : file-like object, string, or None (optional)
+            If `None`, this method returns the report as a string. Otherwise it
+            returns `None` and writes the report to the given file-like object
+            (which must have a ``.write()`` method at a minimum), or to a new
+            file at the path specified.
+
+        indent : int
+            The number of 4 space tabs to indent the report.
+
+        overwrite : bool, optional
+            If ``True``, overwrite the output file if it exists. Raises an
+            ``OSError`` if ``False`` and the output file exists. Default is
+            ``False``.
+
+            .. versionchanged:: 1.3
+               ``overwrite`` replaces the deprecated ``clobber`` argument.
+
+        Returns
+        -------
+        report : str or None
+        """
+
+        return_string = False
+        filepath = None
+
+        if isinstance(fileobj, str):
+            if os.path.exists(fileobj) and not overwrite:
+                raise OSError("File {0} exists, aborting (pass in "
+                              "overwrite=True to overwrite)".format(fileobj))
+            else:
+                filepath = fileobj
+                fileobj = open(filepath, 'w')
+        elif fileobj is None:
+            fileobj = io.StringIO()
+            return_string = True
+
+        self._fileobj = fileobj
+        self._indent = indent  # This is used internally by _writeln
+
+        try:
+            self._report()
+        finally:
+            if filepath:
+                fileobj.close()
+
+        if return_string:
+            return fileobj.getvalue()
+
+    def _writeln(self, text):
+        self._fileobj.write(fixed_width_indent(text, self._indent) + '\n')
+
+    def _diff(self):
+        raise NotImplementedError
+
+    def _report(self):
+        raise NotImplementedError
+
+
+class FITSDiff(_BaseDiff):
+    """Diff two FITS files by filename, or two `HDUList` objects.
+
+    `FITSDiff` objects have the following diff attributes:
+
+    - ``diff_hdu_count``: If the FITS files being compared have different
+      numbers of HDUs, this contains a 2-tuple of the number of HDUs in each
+      file.
+
+    - ``diff_hdus``: If any HDUs with the same index are different, this
+      contains a list of 2-tuples of the HDU index and the `HDUDiff` object
+      representing the differences between the two HDUs.
+    """
+
+    def __init__(self, a, b, ignore_hdus=[], ignore_keywords=[],
+                 ignore_comments=[], ignore_fields=[],
+                 numdiffs=10, rtol=0.0, atol=0.0,
+                 ignore_blanks=True, ignore_blank_cards=True, tolerance=None):
+        """
+        Parameters
+        ----------
+        a : str or `HDUList`
+            The filename of a FITS file on disk, or an `HDUList` object.
+
+        b : str or `HDUList`
+            The filename of a FITS file on disk, or an `HDUList` object to
+            compare to the first file.
+
+        ignore_hdus : sequence, optional
+            HDU names to ignore when comparing two FITS files or HDU lists; the
+            presence of these HDUs and their contents are ignored.  Wildcard
+            strings may also be included in the list.
+
+        ignore_keywords : sequence, optional
+            Header keywords to ignore when comparing two headers; the presence
+            of these keywords and their values are ignored.  Wildcard strings
+            may also be included in the list.
+
+        ignore_comments : sequence, optional
+            A list of header keywords whose comments should be ignored in the
+            comparison.  May contain wildcard strings as with ignore_keywords.
+
+        ignore_fields : sequence, optional
+            The (case-insensitive) names of any table columns to ignore if any
+            table data is to be compared.
+
+        numdiffs : int, optional
+            The number of pixel/table values to output when reporting HDU data
+            differences.  Though the count of differences is the same either
+            way, this allows controlling the number of different values that
+            are kept in memory or output.  If a negative value is given, then
+            numdiffs is treated as unlimited (default: 10).
+
+        rtol : float, optional
+            The relative difference to allow when comparing two float values
+            either in header values, image arrays, or table columns
+            (default: 0.0). Values which satisfy the expression
+
+            .. math::
+
+                \\left| a - b \\right| > \\text{atol} + \\text{rtol} \\cdot \\left| b \\right|
+
+            are considered to be different.
+            The underlying function used for comparison is `numpy.allclose`.
+
+            .. versionchanged:: 2.0
+               ``rtol`` replaces the deprecated ``tolerance`` argument.
+
+        atol : float, optional
+            The allowed absolute difference. See also ``rtol`` parameter.
+
+            .. versionadded:: 2.0
+
+        ignore_blanks : bool, optional
+            Ignore extra whitespace at the end of string values either in
+            headers or data. Extra leading whitespace is not ignored
+            (default: True).
+
+        ignore_blank_cards : bool, optional
+            Ignore all cards that are blank, i.e. they only contain
+            whitespace (default: True).
+        """
+
+        if isinstance(a, str):
+            try:
+                a = fitsopen(a)
+            except Exception as exc:
+                raise OSError("error opening file a ({}): {}: {}".format(
+                        a, exc.__class__.__name__, exc.args[0]))
+            close_a = True
+        else:
+            close_a = False
+
+        if isinstance(b, str):
+            try:
+                b = fitsopen(b)
+            except Exception as exc:
+                raise OSError("error opening file b ({}): {}: {}".format(
+                        b, exc.__class__.__name__, exc.args[0]))
+            close_b = True
+        else:
+            close_b = False
+
+        # Normalize keywords/fields to ignore to upper case
+        self.ignore_hdus = set(k.upper() for k in ignore_hdus)
+        self.ignore_keywords = set(k.upper() for k in ignore_keywords)
+        self.ignore_comments = set(k.upper() for k in ignore_comments)
+        self.ignore_fields = set(k.upper() for k in ignore_fields)
+
+        self.numdiffs = numdiffs
+        self.rtol = rtol
+        self.atol = atol
+
+        if tolerance is not None:  # This should be removed in the next astropy version
+            warnings.warn(
+                '"tolerance" was deprecated in version 2.0 and will be removed in '
+                'a future version. Use argument "rtol" instead.',
+                AstropyDeprecationWarning)
+            self.rtol = tolerance  # when tolerance is provided *always* ignore `rtol`
+                                   # during the transition/deprecation period
+
+        self.ignore_blanks = ignore_blanks
+        self.ignore_blank_cards = ignore_blank_cards
+
+        # Some hdu names may be pattern wildcards.  Find them.
+        self.ignore_hdu_patterns = set()
+        for name in list(self.ignore_hdus):
+            if name != '*' and glob.has_magic(name):
+                self.ignore_hdus.remove(name)
+                self.ignore_hdu_patterns.add(name)
+
+        self.diff_hdu_count = ()
+        self.diff_hdus = []
+
+        try:
+            super().__init__(a, b)
+        finally:
+            if close_a:
+                a.close()
+            if close_b:
+                b.close()
+
+    def _diff(self):
+        if len(self.a) != len(self.b):
+            self.diff_hdu_count = (len(self.a), len(self.b))
+
+        # Record filenames for use later in _report
+        self.filenamea = self.a.filename()
+        if not self.filenamea:
+            self.filenamea = '<{} object at {:#x}>'.format(
+                self.a.__class__.__name__, id(self.a))
+
+        self.filenameb = self.b.filename()
+        if not self.filenameb:
+            self.filenameb = '<{} object at {:#x}>'.format(
+                self.b.__class__.__name__, id(self.b))
+
+        if self.ignore_hdus:
+            self.a = HDUList([h for h in self.a if h.name not in self.ignore_hdus])
+            self.b = HDUList([h for h in self.b if h.name not in self.ignore_hdus])
+        if self.ignore_hdu_patterns:
+            a_names = [hdu.name for hdu in self.a]
+            b_names = [hdu.name for hdu in self.b]
+            for pattern in self.ignore_hdu_patterns:
+                self.a = HDUList([h for h in self.a if h.name not in fnmatch.filter(
+                    a_names, pattern)])
+                self.b = HDUList([h for h in self.b if h.name not in fnmatch.filter(
+                    b_names, pattern)])
+
+        # For now, just compare the extensions one by one in order.
+        # Might allow some more sophisticated types of diffing later.
+
+        # TODO: Somehow or another simplify the passing around of diff
+        # options--this will become important as the number of options grows
+        for idx in range(min(len(self.a), len(self.b))):
+            hdu_diff = HDUDiff.fromdiff(self, self.a[idx], self.b[idx])
+
+            if not hdu_diff.identical:
+                self.diff_hdus.append((idx, hdu_diff))
+
+    def _report(self):
+        wrapper = textwrap.TextWrapper(initial_indent='  ',
+                                       subsequent_indent='  ')
+
+        self._fileobj.write('\n')
+        self._writeln(' fitsdiff: {}'.format(__version__))
+        self._writeln(' a: {}\n b: {}'.format(self.filenamea, self.filenameb))
+
+        if self.ignore_hdus:
+            ignore_hdus = ' '.join(sorted(self.ignore_hdus))
+            self._writeln(' HDU(s) not to be compared:\n{}'
+                          .format(wrapper.fill(ignore_hdus)))
+
+        if self.ignore_hdu_patterns:
+            ignore_hdu_patterns = ' '.join(sorted(self.ignore_hdu_patterns))
+            self._writeln(' HDU(s) not to be compared:\n{}'
+                          .format(wrapper.fill(ignore_hdu_patterns)))
+
+        if self.ignore_keywords:
+            ignore_keywords = ' '.join(sorted(self.ignore_keywords))
+            self._writeln(' Keyword(s) not to be compared:\n{}'
+                          .format(wrapper.fill(ignore_keywords)))
+
+        if self.ignore_comments:
+            ignore_comments = ' '.join(sorted(self.ignore_comments))
+            self._writeln(' Keyword(s) whose comments are not to be compared'
+                          ':\n{}'.format(wrapper.fill(ignore_comments)))
+
+        if self.ignore_fields:
+            ignore_fields = ' '.join(sorted(self.ignore_fields))
+            self._writeln(' Table column(s) not to be compared:\n{}'
+                          .format(wrapper.fill(ignore_fields)))
+
+        self._writeln(' Maximum number of different data values to be '
+                      'reported: {}'.format(self.numdiffs))
+        self._writeln(' Relative tolerance: {}, Absolute tolerance: {}'
+                      .format(self.rtol, self.atol))
+
+        if self.diff_hdu_count:
+            self._fileobj.write('\n')
+            self._writeln('Files contain different numbers of HDUs:')
+            self._writeln(' a: {}'.format(self.diff_hdu_count[0]))
+            self._writeln(' b: {}'.format(self.diff_hdu_count[1]))
+
+            if not self.diff_hdus:
+                self._writeln('No differences found between common HDUs.')
+                return
+        elif not self.diff_hdus:
+            self._fileobj.write('\n')
+            self._writeln('No differences found.')
+            return
+
+        for idx, hdu_diff in self.diff_hdus:
+            # print out the extension heading
+            if idx == 0:
+                self._fileobj.write('\n')
+                self._writeln('Primary HDU:')
+            else:
+                self._fileobj.write('\n')
+                self._writeln('Extension HDU {}:'.format(idx))
+            hdu_diff.report(self._fileobj, indent=self._indent + 1)
+
+
+class HDUDiff(_BaseDiff):
+    """
+    Diff two HDU objects, including their headers and their data (but only if
+    both HDUs contain the same type of data (image, table, or unknown).
+
+    `HDUDiff` objects have the following diff attributes:
+
+    - ``diff_extnames``: If the two HDUs have different EXTNAME values, this
+      contains a 2-tuple of the different extension names.
+
+    - ``diff_extvers``: If the two HDUS have different EXTVER values, this
+      contains a 2-tuple of the different extension versions.
+
+    - ``diff_extlevels``: If the two HDUs have different EXTLEVEL values, this
+      contains a 2-tuple of the different extension levels.
+
+    - ``diff_extension_types``: If the two HDUs have different XTENSION values,
+      this contains a 2-tuple of the different extension types.
+
+    - ``diff_headers``: Contains a `HeaderDiff` object for the headers of the
+      two HDUs. This will always contain an object--it may be determined
+      whether the headers are different through ``diff_headers.identical``.
+
+    - ``diff_data``: Contains either a `ImageDataDiff`, `TableDataDiff`, or
+      `RawDataDiff` as appropriate for the data in the HDUs, and only if the
+      two HDUs have non-empty data of the same type (`RawDataDiff` is used for
+      HDUs containing non-empty data of an indeterminate type).
+    """
+
+    def __init__(self, a, b, ignore_keywords=[], ignore_comments=[],
+                 ignore_fields=[], numdiffs=10, rtol=0.0, atol=0.0,
+                 ignore_blanks=True, ignore_blank_cards=True, tolerance=None):
+        """
+        Parameters
+        ----------
+        a : `HDUList`
+            An `HDUList` object.
+
+        b : str or `HDUList`
+            An `HDUList` object to compare to the first `HDUList` object.
+
+        ignore_keywords : sequence, optional
+            Header keywords to ignore when comparing two headers; the presence
+            of these keywords and their values are ignored.  Wildcard strings
+            may also be included in the list.
+
+        ignore_comments : sequence, optional
+            A list of header keywords whose comments should be ignored in the
+            comparison.  May contain wildcard strings as with ignore_keywords.
+
+        ignore_fields : sequence, optional
+            The (case-insensitive) names of any table columns to ignore if any
+            table data is to be compared.
+
+        numdiffs : int, optional
+            The number of pixel/table values to output when reporting HDU data
+            differences.  Though the count of differences is the same either
+            way, this allows controlling the number of different values that
+            are kept in memory or output.  If a negative value is given, then
+            numdiffs is treated as unlimited (default: 10).
+
+        rtol : float, optional
+            The relative difference to allow when comparing two float values
+            either in header values, image arrays, or table columns
+            (default: 0.0). Values which satisfy the expression
+
+            .. math::
+
+                \\left| a - b \\right| > \\text{atol} + \\text{rtol} \\cdot \\left| b \\right|
+
+            are considered to be different.
+            The underlying function used for comparison is `numpy.allclose`.
+
+            .. versionchanged:: 2.0
+               ``rtol`` replaces the deprecated ``tolerance`` argument.
+
+        atol : float, optional
+            The allowed absolute difference. See also ``rtol`` parameter.
+
+            .. versionadded:: 2.0
+
+        ignore_blanks : bool, optional
+            Ignore extra whitespace at the end of string values either in
+            headers or data. Extra leading whitespace is not ignored
+            (default: True).
+
+        ignore_blank_cards : bool, optional
+            Ignore all cards that are blank, i.e. they only contain
+            whitespace (default: True).
+        """
+
+        self.ignore_keywords = {k.upper() for k in ignore_keywords}
+        self.ignore_comments = {k.upper() for k in ignore_comments}
+        self.ignore_fields = {k.upper() for k in ignore_fields}
+
+        self.rtol = rtol
+        self.atol = atol
+
+        if tolerance is not None:  # This should be removed in the next astropy version
+            warnings.warn(
+                '"tolerance" was deprecated in version 2.0 and will be removed in '
+                'a future version. Use argument "rtol" instead.',
+                AstropyDeprecationWarning)
+            self.rtol = tolerance  # when tolerance is provided *always* ignore `rtol`
+                                   # during the transition/deprecation period
+
+        self.numdiffs = numdiffs
+        self.ignore_blanks = ignore_blanks
+
+        self.diff_extnames = ()
+        self.diff_extvers = ()
+        self.diff_extlevels = ()
+        self.diff_extension_types = ()
+        self.diff_headers = None
+        self.diff_data = None
+
+        super().__init__(a, b)
+
+    def _diff(self):
+        if self.a.name != self.b.name:
+            self.diff_extnames = (self.a.name, self.b.name)
+
+        if self.a.ver != self.b.ver:
+            self.diff_extvers = (self.a.ver, self.b.ver)
+
+        if self.a.level != self.b.level:
+            self.diff_extlevels = (self.a.level, self.b.level)
+
+        if self.a.header.get('XTENSION') != self.b.header.get('XTENSION'):
+            self.diff_extension_types = (self.a.header.get('XTENSION'),
+                                         self.b.header.get('XTENSION'))
+
+        self.diff_headers = HeaderDiff.fromdiff(self, self.a.header.copy(),
+                                                self.b.header.copy())
+
+        if self.a.data is None or self.b.data is None:
+            # TODO: Perhaps have some means of marking this case
+            pass
+        elif self.a.is_image and self.b.is_image:
+            self.diff_data = ImageDataDiff.fromdiff(self, self.a.data,
+                                                    self.b.data)
+        elif (isinstance(self.a, _TableLikeHDU) and
+              isinstance(self.b, _TableLikeHDU)):
+            # TODO: Replace this if/when _BaseHDU grows a .is_table property
+            self.diff_data = TableDataDiff.fromdiff(self, self.a.data,
+                                                    self.b.data)
+        elif not self.diff_extension_types:
+            # Don't diff the data for unequal extension types that are not
+            # recognized image or table types
+            self.diff_data = RawDataDiff.fromdiff(self, self.a.data,
+                                                  self.b.data)
+
+    def _report(self):
+        if self.identical:
+            self._writeln(" No differences found.")
+        if self.diff_extension_types:
+            self._writeln(" Extension types differ:\n  a: {}\n  "
+                          "b: {}".format(*self.diff_extension_types))
+        if self.diff_extnames:
+            self._writeln(" Extension names differ:\n  a: {}\n  "
+                          "b: {}".format(*self.diff_extnames))
+        if self.diff_extvers:
+            self._writeln(" Extension versions differ:\n  a: {}\n  "
+                          "b: {}".format(*self.diff_extvers))
+
+        if self.diff_extlevels:
+            self._writeln(" Extension levels differ:\n  a: {}\n  "
+                          "b: {}".format(*self.diff_extlevels))
+
+        if not self.diff_headers.identical:
+            self._fileobj.write('\n')
+            self._writeln(" Headers contain differences:")
+            self.diff_headers.report(self._fileobj, indent=self._indent + 1)
+
+        if self.diff_data is not None and not self.diff_data.identical:
+            self._fileobj.write('\n')
+            self._writeln(" Data contains differences:")
+            self.diff_data.report(self._fileobj, indent=self._indent + 1)
+
+
+class HeaderDiff(_BaseDiff):
+    """
+    Diff two `Header` objects.
+
+    `HeaderDiff` objects have the following diff attributes:
+
+    - ``diff_keyword_count``: If the two headers contain a different number of
+      keywords, this contains a 2-tuple of the keyword count for each header.
+
+    - ``diff_keywords``: If either header contains one or more keywords that
+      don't appear at all in the other header, this contains a 2-tuple
+      consisting of a list of the keywords only appearing in header a, and a
+      list of the keywords only appearing in header b.
+
+    - ``diff_duplicate_keywords``: If a keyword appears in both headers at
+      least once, but contains a different number of duplicates (for example, a
+      different number of HISTORY cards in each header), an item is added to
+      this dict with the keyword as the key, and a 2-tuple of the different
+      counts of that keyword as the value.  For example::
+
+          {'HISTORY': (20, 19)}
+
+      means that header a contains 20 HISTORY cards, while header b contains
+      only 19 HISTORY cards.
+
+    - ``diff_keyword_values``: If any of the common keyword between the two
+      headers have different values, they appear in this dict.  It has a
+      structure similar to ``diff_duplicate_keywords``, with the keyword as the
+      key, and a 2-tuple of the different values as the value.  For example::
+
+          {'NAXIS': (2, 3)}
+
+      means that the NAXIS keyword has a value of 2 in header a, and a value of
+      3 in header b.  This excludes any keywords matched by the
+      ``ignore_keywords`` list.
+
+    - ``diff_keyword_comments``: Like ``diff_keyword_values``, but contains
+      differences between keyword comments.
+
+    `HeaderDiff` objects also have a ``common_keywords`` attribute that lists
+    all keywords that appear in both headers.
+    """
+
+    def __init__(self, a, b, ignore_keywords=[], ignore_comments=[],
+                 rtol=0.0, atol=0.0, ignore_blanks=True, ignore_blank_cards=True,
+                 tolerance=None):
+        """
+        Parameters
+        ----------
+        a : `HDUList`
+            An `HDUList` object.
+
+        b : `HDUList`
+            An `HDUList` object to compare to the first `HDUList` object.
+
+        ignore_keywords : sequence, optional
+            Header keywords to ignore when comparing two headers; the presence
+            of these keywords and their values are ignored.  Wildcard strings
+            may also be included in the list.
+
+        ignore_comments : sequence, optional
+            A list of header keywords whose comments should be ignored in the
+            comparison.  May contain wildcard strings as with ignore_keywords.
+
+        numdiffs : int, optional
+            The number of pixel/table values to output when reporting HDU data
+            differences.  Though the count of differences is the same either
+            way, this allows controlling the number of different values that
+            are kept in memory or output.  If a negative value is given, then
+            numdiffs is treated as unlimited (default: 10).
+
+        rtol : float, optional
+            The relative difference to allow when comparing two float values
+            either in header values, image arrays, or table columns
+            (default: 0.0). Values which satisfy the expression
+
+            .. math::
+
+                \\left| a - b \\right| > \\text{atol} + \\text{rtol} \\cdot \\left| b \\right|
+
+            are considered to be different.
+            The underlying function used for comparison is `numpy.allclose`.
+
+            .. versionchanged:: 2.0
+               ``rtol`` replaces the deprecated ``tolerance`` argument.
+
+        atol : float, optional
+            The allowed absolute difference. See also ``rtol`` parameter.
+
+            .. versionadded:: 2.0
+
+        ignore_blanks : bool, optional
+            Ignore extra whitespace at the end of string values either in
+            headers or data. Extra leading whitespace is not ignored
+            (default: True).
+
+        ignore_blank_cards : bool, optional
+            Ignore all cards that are blank, i.e. they only contain
+            whitespace (default: True).
+        """
+
+        self.ignore_keywords = {k.upper() for k in ignore_keywords}
+        self.ignore_comments = {k.upper() for k in ignore_comments}
+
+        self.rtol = rtol
+        self.atol = atol
+
+        if tolerance is not None:  # This should be removed in the next astropy version
+            warnings.warn(
+                '"tolerance" was deprecated in version 2.0 and will be removed in '
+                'a future version. Use argument "rtol" instead.',
+                AstropyDeprecationWarning)
+            self.rtol = tolerance  # when tolerance is provided *always* ignore `rtol`
+                                   # during the transition/deprecation period
+
+        self.ignore_blanks = ignore_blanks
+        self.ignore_blank_cards = ignore_blank_cards
+
+        self.ignore_keyword_patterns = set()
+        self.ignore_comment_patterns = set()
+        for keyword in list(self.ignore_keywords):
+            keyword = keyword.upper()
+            if keyword != '*' and glob.has_magic(keyword):
+                self.ignore_keywords.remove(keyword)
+                self.ignore_keyword_patterns.add(keyword)
+        for keyword in list(self.ignore_comments):
+            keyword = keyword.upper()
+            if keyword != '*' and glob.has_magic(keyword):
+                self.ignore_comments.remove(keyword)
+                self.ignore_comment_patterns.add(keyword)
+
+        # Keywords appearing in each header
+        self.common_keywords = []
+
+        # Set to the number of keywords in each header if the counts differ
+        self.diff_keyword_count = ()
+
+        # Set if the keywords common to each header (excluding ignore_keywords)
+        # appear in different positions within the header
+        # TODO: Implement this
+        self.diff_keyword_positions = ()
+
+        # Keywords unique to each header (excluding keywords in
+        # ignore_keywords)
+        self.diff_keywords = ()
+
+        # Keywords that have different numbers of duplicates in each header
+        # (excluding keywords in ignore_keywords)
+        self.diff_duplicate_keywords = {}
+
+        # Keywords common to each header but having different values (excluding
+        # keywords in ignore_keywords)
+        self.diff_keyword_values = defaultdict(list)
+
+        # Keywords common to each header but having different comments
+        # (excluding keywords in ignore_keywords or in ignore_comments)
+        self.diff_keyword_comments = defaultdict(list)
+
+        if isinstance(a, str):
+            a = Header.fromstring(a)
+        if isinstance(b, str):
+            b = Header.fromstring(b)
+
+        if not (isinstance(a, Header) and isinstance(b, Header)):
+            raise TypeError('HeaderDiff can only diff astropy.io.fits.Header '
+                            'objects or strings containing FITS headers.')
+
+        super().__init__(a, b)
+
+    # TODO: This doesn't pay much attention to the *order* of the keywords,
+    # except in the case of duplicate keywords.  The order should be checked
+    # too, or at least it should be an option.
+    def _diff(self):
+        if self.ignore_blank_cards:
+            cardsa = [c for c in self.a.cards if str(c) != BLANK_CARD]
+            cardsb = [c for c in self.b.cards if str(c) != BLANK_CARD]
+        else:
+            cardsa = list(self.a.cards)
+            cardsb = list(self.b.cards)
+
+        # build dictionaries of keyword values and comments
+        def get_header_values_comments(cards):
+            values = {}
+            comments = {}
+            for card in cards:
+                value = card.value
+                if self.ignore_blanks and isinstance(value, str):
+                    value = value.rstrip()
+                values.setdefault(card.keyword, []).append(value)
+                comments.setdefault(card.keyword, []).append(card.comment)
+            return values, comments
+
+        valuesa, commentsa = get_header_values_comments(cardsa)
+        valuesb, commentsb = get_header_values_comments(cardsb)
+
+        # Normalize all keyword to upper-case for comparison's sake;
+        # TODO: HIERARCH keywords should be handled case-sensitively I think
+        keywordsa = {k.upper() for k in valuesa}
+        keywordsb = {k.upper() for k in valuesb}
+
+        self.common_keywords = sorted(keywordsa.intersection(keywordsb))
+        if len(cardsa) != len(cardsb):
+            self.diff_keyword_count = (len(cardsa), len(cardsb))
+
+        # Any other diff attributes should exclude ignored keywords
+        keywordsa = keywordsa.difference(self.ignore_keywords)
+        keywordsb = keywordsb.difference(self.ignore_keywords)
+        if self.ignore_keyword_patterns:
+            for pattern in self.ignore_keyword_patterns:
+                keywordsa = keywordsa.difference(fnmatch.filter(keywordsa,
+                                                                pattern))
+                keywordsb = keywordsb.difference(fnmatch.filter(keywordsb,
+                                                                pattern))
+
+        if '*' in self.ignore_keywords:
+            # Any other differences between keywords are to be ignored
+            return
+
+        left_only_keywords = sorted(keywordsa.difference(keywordsb))
+        right_only_keywords = sorted(keywordsb.difference(keywordsa))
+
+        if left_only_keywords or right_only_keywords:
+            self.diff_keywords = (left_only_keywords, right_only_keywords)
+
+        # Compare count of each common keyword
+        for keyword in self.common_keywords:
+            if keyword in self.ignore_keywords:
+                continue
+            if self.ignore_keyword_patterns:
+                skip = False
+                for pattern in self.ignore_keyword_patterns:
+                    if fnmatch.fnmatch(keyword, pattern):
+                        skip = True
+                        break
+                if skip:
+                    continue
+
+            counta = len(valuesa[keyword])
+            countb = len(valuesb[keyword])
+            if counta != countb:
+                self.diff_duplicate_keywords[keyword] = (counta, countb)
+
+            # Compare keywords' values and comments
+            for a, b in zip(valuesa[keyword], valuesb[keyword]):
+                if diff_values(a, b, rtol=self.rtol, atol=self.atol):
+                    self.diff_keyword_values[keyword].append((a, b))
+                else:
+                    # If there are duplicate keywords we need to be able to
+                    # index each duplicate; if the values of a duplicate
+                    # are identical use None here
+                    self.diff_keyword_values[keyword].append(None)
+
+            if not any(self.diff_keyword_values[keyword]):
+                # No differences found; delete the array of Nones
+                del self.diff_keyword_values[keyword]
+
+            if '*' in self.ignore_comments or keyword in self.ignore_comments:
+                continue
+            if self.ignore_comment_patterns:
+                skip = False
+                for pattern in self.ignore_comment_patterns:
+                    if fnmatch.fnmatch(keyword, pattern):
+                        skip = True
+                        break
+                if skip:
+                    continue
+
+            for a, b in zip(commentsa[keyword], commentsb[keyword]):
+                if diff_values(a, b):
+                    self.diff_keyword_comments[keyword].append((a, b))
+                else:
+                    self.diff_keyword_comments[keyword].append(None)
+
+            if not any(self.diff_keyword_comments[keyword]):
+                del self.diff_keyword_comments[keyword]
+
+    def _report(self):
+        if self.diff_keyword_count:
+            self._writeln(' Headers have different number of cards:')
+            self._writeln('  a: {}'.format(self.diff_keyword_count[0]))
+            self._writeln('  b: {}'.format(self.diff_keyword_count[1]))
+        if self.diff_keywords:
+            for keyword in self.diff_keywords[0]:
+                if keyword in Card._commentary_keywords:
+                    val = self.a[keyword][0]
+                else:
+                    val = self.a[keyword]
+                self._writeln(' Extra keyword {!r:8} in a: {!r}'.format(
+                                keyword, val))
+            for keyword in self.diff_keywords[1]:
+                if keyword in Card._commentary_keywords:
+                    val = self.b[keyword][0]
+                else:
+                    val = self.b[keyword]
+                self._writeln(' Extra keyword {!r:8} in b: {!r}'.format(
+                                keyword, val))
+
+        if self.diff_duplicate_keywords:
+            for keyword, count in sorted(self.diff_duplicate_keywords.items()):
+                self._writeln(' Inconsistent duplicates of keyword {!r:8}:'
+                              .format(keyword))
+                self._writeln('  Occurs {} time(s) in a, {} times in (b)'
+                              .format(*count))
+
+        if self.diff_keyword_values or self.diff_keyword_comments:
+            for keyword in self.common_keywords:
+                report_diff_keyword_attr(self._fileobj, 'values',
+                                         self.diff_keyword_values, keyword,
+                                         ind=self._indent)
+                report_diff_keyword_attr(self._fileobj, 'comments',
+                                         self.diff_keyword_comments, keyword,
+                                         ind=self._indent)
+
+# TODO: It might be good if there was also a threshold option for percentage of
+# different pixels: For example ignore if only 1% of the pixels are different
+# within some threshold.  There are lots of possibilities here, but hold off
+# for now until specific cases come up.
+
+
+class ImageDataDiff(_BaseDiff):
+    """
+    Diff two image data arrays (really any array from a PRIMARY HDU or an IMAGE
+    extension HDU, though the data unit is assumed to be "pixels").
+
+    `ImageDataDiff` objects have the following diff attributes:
+
+    - ``diff_dimensions``: If the two arrays contain either a different number
+      of dimensions or different sizes in any dimension, this contains a
+      2-tuple of the shapes of each array.  Currently no further comparison is
+      performed on images that don't have the exact same dimensions.
+
+    - ``diff_pixels``: If the two images contain any different pixels, this
+      contains a list of 2-tuples of the array index where the difference was
+      found, and another 2-tuple containing the different values.  For example,
+      if the pixel at (0, 0) contains different values this would look like::
+
+          [(0, 0), (1.1, 2.2)]
+
+      where 1.1 and 2.2 are the values of that pixel in each array.  This
+      array only contains up to ``self.numdiffs`` differences, for storage
+      efficiency.
+
+    - ``diff_total``: The total number of different pixels found between the
+      arrays.  Although ``diff_pixels`` does not necessarily contain all the
+      different pixel values, this can be used to get a count of the total
+      number of differences found.
+
+    - ``diff_ratio``: Contains the ratio of ``diff_total`` to the total number
+      of pixels in the arrays.
+    """
+
+    def __init__(self, a, b, numdiffs=10, rtol=0.0, atol=0.0, tolerance=None):
+        """
+        Parameters
+        ----------
+        a : `HDUList`
+            An `HDUList` object.
+
+        b : `HDUList`
+            An `HDUList` object to compare to the first `HDUList` object.
+
+        numdiffs : int, optional
+            The number of pixel/table values to output when reporting HDU data
+            differences.  Though the count of differences is the same either
+            way, this allows controlling the number of different values that
+            are kept in memory or output.  If a negative value is given, then
+            numdiffs is treated as unlimited (default: 10).
+
+        rtol : float, optional
+            The relative difference to allow when comparing two float values
+            either in header values, image arrays, or table columns
+            (default: 0.0). Values which satisfy the expression
+
+            .. math::
+
+                \\left| a - b \\right| > \\text{atol} + \\text{rtol} \\cdot \\left| b \\right|
+
+            are considered to be different.
+            The underlying function used for comparison is `numpy.allclose`.
+
+            .. versionchanged:: 2.0
+               ``rtol`` replaces the deprecated ``tolerance`` argument.
+
+        atol : float, optional
+            The allowed absolute difference. See also ``rtol`` parameter.
+
+            .. versionadded:: 2.0
+        """
+
+        self.numdiffs = numdiffs
+        self.rtol = rtol
+        self.atol = atol
+
+        if tolerance is not None:  # This should be removed in the next astropy version
+            warnings.warn(
+                '"tolerance" was deprecated in version 2.0 and will be removed in '
+                'a future version. Use argument "rtol" instead.',
+                AstropyDeprecationWarning)
+            self.rtol = tolerance  # when tolerance is provided *always* ignore `rtol`
+                                   # during the transition/deprecation period
+
+        self.diff_dimensions = ()
+        self.diff_pixels = []
+        self.diff_ratio = 0
+
+        # self.diff_pixels only holds up to numdiffs differing pixels, but this
+        # self.diff_total stores the total count of differences between
+        # the images, but not the different values
+        self.diff_total = 0
+
+        super().__init__(a, b)
+
+    def _diff(self):
+        if self.a.shape != self.b.shape:
+            self.diff_dimensions = (self.a.shape, self.b.shape)
+            # Don't do any further comparison if the dimensions differ
+            # TODO: Perhaps we could, however, diff just the intersection
+            # between the two images
+            return
+
+        # Find the indices where the values are not equal
+        # If neither a nor b are floating point (or complex), ignore rtol and
+        # atol
+        if not (np.issubdtype(self.a.dtype, np.inexact) or
+                np.issubdtype(self.b.dtype, np.inexact)):
+            rtol = 0
+            atol = 0
+        else:
+            rtol = self.rtol
+            atol = self.atol
+
+        diffs = where_not_allclose(self.a, self.b, atol=atol, rtol=rtol)
+
+        self.diff_total = len(diffs[0])
+
+        if self.diff_total == 0:
+            # Then we're done
+            return
+
+        if self.numdiffs < 0:
+            numdiffs = self.diff_total
+        else:
+            numdiffs = self.numdiffs
+
+        self.diff_pixels = [(idx, (self.a[idx], self.b[idx]))
+                            for idx in islice(zip(*diffs), 0, numdiffs)]
+        self.diff_ratio = float(self.diff_total) / float(len(self.a.flat))
+
+    def _report(self):
+        if self.diff_dimensions:
+            dimsa = ' x '.join(str(d) for d in
+                               reversed(self.diff_dimensions[0]))
+            dimsb = ' x '.join(str(d) for d in
+                               reversed(self.diff_dimensions[1]))
+            self._writeln(' Data dimensions differ:')
+            self._writeln('  a: {}'.format(dimsa))
+            self._writeln('  b: {}'.format(dimsb))
+            # For now we don't do any further comparison if the dimensions
+            # differ; though in the future it might be nice to be able to
+            # compare at least where the images intersect
+            self._writeln(' No further data comparison performed.')
+            return
+
+        if not self.diff_pixels:
+            return
+
+        for index, values in self.diff_pixels:
+            index = [x + 1 for x in reversed(index)]
+            self._writeln(' Data differs at {}:'.format(index))
+            report_diff_values(values[0], values[1], fileobj=self._fileobj,
+                               indent_width=self._indent + 1)
+
+        if self.diff_total > self.numdiffs:
+            self._writeln(' ...')
+        self._writeln(' {} different pixels found ({:.2%} different).'
+                      .format(self.diff_total, self.diff_ratio))
+
+
+class RawDataDiff(ImageDataDiff):
+    """
+    `RawDataDiff` is just a special case of `ImageDataDiff` where the images
+    are one-dimensional, and the data is treated as a 1-dimensional array of
+    bytes instead of pixel values.  This is used to compare the data of two
+    non-standard extension HDUs that were not recognized as containing image or
+    table data.
+
+    `ImageDataDiff` objects have the following diff attributes:
+
+    - ``diff_dimensions``: Same as the ``diff_dimensions`` attribute of
+      `ImageDataDiff` objects. Though the "dimension" of each array is just an
+      integer representing the number of bytes in the data.
+
+    - ``diff_bytes``: Like the ``diff_pixels`` attribute of `ImageDataDiff`
+      objects, but renamed to reflect the minor semantic difference that these
+      are raw bytes and not pixel values.  Also the indices are integers
+      instead of tuples.
+
+    - ``diff_total`` and ``diff_ratio``: Same as `ImageDataDiff`.
+    """
+
+    def __init__(self, a, b, numdiffs=10):
+        """
+        Parameters
+        ----------
+        a : `HDUList`
+            An `HDUList` object.
+
+        b : `HDUList`
+            An `HDUList` object to compare to the first `HDUList` object.
+
+        numdiffs : int, optional
+            The number of pixel/table values to output when reporting HDU data
+            differences.  Though the count of differences is the same either
+            way, this allows controlling the number of different values that
+            are kept in memory or output.  If a negative value is given, then
+            numdiffs is treated as unlimited (default: 10).
+        """
+
+        self.diff_dimensions = ()
+        self.diff_bytes = []
+
+        super().__init__(a, b, numdiffs=numdiffs)
+
+    def _diff(self):
+        super()._diff()
+        if self.diff_dimensions:
+            self.diff_dimensions = (self.diff_dimensions[0][0],
+                                    self.diff_dimensions[1][0])
+
+        self.diff_bytes = [(x[0], y) for x, y in self.diff_pixels]
+        del self.diff_pixels
+
+    def _report(self):
+        if self.diff_dimensions:
+            self._writeln(' Data sizes differ:')
+            self._writeln('  a: {} bytes'.format(self.diff_dimensions[0]))
+            self._writeln('  b: {} bytes'.format(self.diff_dimensions[1]))
+            # For now we don't do any further comparison if the dimensions
+            # differ; though in the future it might be nice to be able to
+            # compare at least where the images intersect
+            self._writeln(' No further data comparison performed.')
+            return
+
+        if not self.diff_bytes:
+            return
+
+        for index, values in self.diff_bytes:
+            self._writeln(' Data differs at byte {}:'.format(index))
+            report_diff_values(values[0], values[1], fileobj=self._fileobj,
+                               indent_width=self._indent + 1)
+
+        self._writeln(' ...')
+        self._writeln(' {} different bytes found ({:.2%} different).'
+                      .format(self.diff_total, self.diff_ratio))
+
+
+class TableDataDiff(_BaseDiff):
+    """
+    Diff two table data arrays. It doesn't matter whether the data originally
+    came from a binary or ASCII table--the data should be passed in as a
+    recarray.
+
+    `TableDataDiff` objects have the following diff attributes:
+
+    - ``diff_column_count``: If the tables being compared have different
+      numbers of columns, this contains a 2-tuple of the column count in each
+      table.  Even if the tables have different column counts, an attempt is
+      still made to compare any columns they have in common.
+
+    - ``diff_columns``: If either table contains columns unique to that table,
+      either in name or format, this contains a 2-tuple of lists. The first
+      element is a list of columns (these are full `Column` objects) that
+      appear only in table a.  The second element is a list of tables that
+      appear only in table b.  This only lists columns with different column
+      definitions, and has nothing to do with the data in those columns.
+
+    - ``diff_column_names``: This is like ``diff_columns``, but lists only the
+      names of columns unique to either table, rather than the full `Column`
+      objects.
+
+    - ``diff_column_attributes``: Lists columns that are in both tables but
+      have different secondary attributes, such as TUNIT or TDISP.  The format
+      is a list of 2-tuples: The first a tuple of the column name and the
+      attribute, the second a tuple of the different values.
+
+    - ``diff_values``: `TableDataDiff` compares the data in each table on a
+      column-by-column basis.  If any different data is found, it is added to
+      this list.  The format of this list is similar to the ``diff_pixels``
+      attribute on `ImageDataDiff` objects, though the "index" consists of a
+      (column_name, row) tuple.  For example::
+
+          [('TARGET', 0), ('NGC1001', 'NGC1002')]
+
+      shows that the tables contain different values in the 0-th row of the
+      'TARGET' column.
+
+    - ``diff_total`` and ``diff_ratio``: Same as `ImageDataDiff`.
+
+    `TableDataDiff` objects also have a ``common_columns`` attribute that lists
+    the `Column` objects for columns that are identical in both tables, and a
+    ``common_column_names`` attribute which contains a set of the names of
+    those columns.
+    """
+
+    def __init__(self, a, b, ignore_fields=[], numdiffs=10, rtol=0.0, atol=0.0,
+                 tolerance=None):
+        """
+        Parameters
+        ----------
+        a : `HDUList`
+            An `HDUList` object.
+
+        b : `HDUList`
+            An `HDUList` object to compare to the first `HDUList` object.
+
+        ignore_fields : sequence, optional
+            The (case-insensitive) names of any table columns to ignore if any
+            table data is to be compared.
+
+        numdiffs : int, optional
+            The number of pixel/table values to output when reporting HDU data
+            differences.  Though the count of differences is the same either
+            way, this allows controlling the number of different values that
+            are kept in memory or output.  If a negative value is given, then
+            numdiffs is treated as unlimited (default: 10).
+
+        rtol : float, optional
+            The relative difference to allow when comparing two float values
+            either in header values, image arrays, or table columns
+            (default: 0.0). Values which satisfy the expression
+
+            .. math::
+
+                \\left| a - b \\right| > \\text{atol} + \\text{rtol} \\cdot \\left| b \\right|
+
+            are considered to be different.
+            The underlying function used for comparison is `numpy.allclose`.
+
+            .. versionchanged:: 2.0
+               ``rtol`` replaces the deprecated ``tolerance`` argument.
+
+        atol : float, optional
+            The allowed absolute difference. See also ``rtol`` parameter.
+
+            .. versionadded:: 2.0
+        """
+
+        self.ignore_fields = set(ignore_fields)
+        self.numdiffs = numdiffs
+        self.rtol = rtol
+        self.atol = atol
+
+        if tolerance is not None:  # This should be removed in the next astropy version
+            warnings.warn(
+                '"tolerance" was deprecated in version 2.0 and will be removed in '
+                'a future version. Use argument "rtol" instead.',
+                AstropyDeprecationWarning)
+            self.rtol = tolerance  # when tolerance is provided *always* ignore `rtol`
+                                   # during the transition/deprecation period
+
+        self.common_columns = []
+        self.common_column_names = set()
+
+        # self.diff_columns contains columns with different column definitions,
+        # but not different column data. Column data is only compared in
+        # columns that have the same definitions
+        self.diff_rows = ()
+        self.diff_column_count = ()
+        self.diff_columns = ()
+
+        # If two columns have the same name+format, but other attributes are
+        # different (such as TUNIT or such) they are listed here
+        self.diff_column_attributes = []
+
+        # Like self.diff_columns, but just contains a list of the column names
+        # unique to each table, and in the order they appear in the tables
+        self.diff_column_names = ()
+        self.diff_values = []
+
+        self.diff_ratio = 0
+        self.diff_total = 0
+
+        super().__init__(a, b)
+
+    def _diff(self):
+        # Much of the code for comparing columns is similar to the code for
+        # comparing headers--consider refactoring
+        colsa = self.a.columns
+        colsb = self.b.columns
+
+        if len(colsa) != len(colsb):
+            self.diff_column_count = (len(colsa), len(colsb))
+
+        # Even if the number of columns are unequal, we still do comparison of
+        # any common columns
+        colsa = {c.name.lower(): c for c in colsa}
+        colsb = {c.name.lower(): c for c in colsb}
+
+        if '*' in self.ignore_fields:
+            # If all columns are to be ignored, ignore any further differences
+            # between the columns
+            return
+
+        # Keep the user's original ignore_fields list for reporting purposes,
+        # but internally use a case-insensitive version
+        ignore_fields = {f.lower() for f in self.ignore_fields}
+
+        # It might be nice if there were a cleaner way to do this, but for now
+        # it'll do
+        for fieldname in ignore_fields:
+            fieldname = fieldname.lower()
+            if fieldname in colsa:
+                del colsa[fieldname]
+            if fieldname in colsb:
+                del colsb[fieldname]
+
+        colsa_set = set(colsa.values())
+        colsb_set = set(colsb.values())
+        self.common_columns = sorted(colsa_set.intersection(colsb_set),
+                                     key=operator.attrgetter('name'))
+
+        self.common_column_names = {col.name.lower()
+                                    for col in self.common_columns}
+
+        left_only_columns = {col.name.lower(): col
+                             for col in colsa_set.difference(colsb_set)}
+        right_only_columns = {col.name.lower(): col
+                              for col in colsb_set.difference(colsa_set)}
+
+        if left_only_columns or right_only_columns:
+            self.diff_columns = (left_only_columns, right_only_columns)
+            self.diff_column_names = ([], [])
+
+        if left_only_columns:
+            for col in self.a.columns:
+                if col.name.lower() in left_only_columns:
+                    self.diff_column_names[0].append(col.name)
+
+        if right_only_columns:
+            for col in self.b.columns:
+                if col.name.lower() in right_only_columns:
+                    self.diff_column_names[1].append(col.name)
+
+        # If the tables have a different number of rows, we don't compare the
+        # columns right now.
+        # TODO: It might be nice to optionally compare the first n rows where n
+        # is the minimum of the row counts between the two tables.
+        if len(self.a) != len(self.b):
+            self.diff_rows = (len(self.a), len(self.b))
+            return
+
+        # If the tables contain no rows there's no data to compare, so we're
+        # done at this point. (See ticket #178)
+        if len(self.a) == len(self.b) == 0:
+            return
+
+        # Like in the old fitsdiff, compare tables on a column by column basis
+        # The difficulty here is that, while FITS column names are meant to be
+        # case-insensitive, Astropy still allows, for the sake of flexibility,
+        # two columns with the same name but different case.  When columns are
+        # accessed in FITS tables, a case-sensitive is tried first, and failing
+        # that a case-insensitive match is made.
+        # It's conceivable that the same column could appear in both tables
+        # being compared, but with different case.
+        # Though it *may* lead to inconsistencies in these rare cases, this
+        # just assumes that there are no duplicated column names in either
+        # table, and that the column names can be treated case-insensitively.
+        for col in self.common_columns:
+            name_lower = col.name.lower()
+            if name_lower in ignore_fields:
+                continue
+
+            cola = colsa[name_lower]
+            colb = colsb[name_lower]
+
+            for attr, _ in _COL_ATTRS:
+                vala = getattr(cola, attr, None)
+                valb = getattr(colb, attr, None)
+                if diff_values(vala, valb):
+                    self.diff_column_attributes.append(
+                        ((col.name.upper(), attr), (vala, valb)))
+
+            arra = self.a[col.name]
+            arrb = self.b[col.name]
+
+            if (np.issubdtype(arra.dtype, np.floating) and
+                    np.issubdtype(arrb.dtype, np.floating)):
+                diffs = where_not_allclose(arra, arrb,
+                                           rtol=self.rtol,
+                                           atol=self.atol)
+            elif 'P' in col.format:
+                diffs = ([idx for idx in range(len(arra))
+                          if not np.allclose(arra[idx], arrb[idx],
+                                             rtol=self.rtol,
+                                             atol=self.atol)],)
+            else:
+                diffs = np.where(arra != arrb)
+
+            self.diff_total += len(set(diffs[0]))
+
+            if self.numdiffs >= 0:
+                if len(self.diff_values) >= self.numdiffs:
+                    # Don't save any more diff values
+                    continue
+
+                # Add no more diff'd values than this
+                max_diffs = self.numdiffs - len(self.diff_values)
+            else:
+                max_diffs = len(diffs[0])
+
+            last_seen_idx = None
+            for idx in islice(diffs[0], 0, max_diffs):
+                if idx == last_seen_idx:
+                    # Skip duplicate indices, which my occur when the column
+                    # data contains multi-dimensional values; we're only
+                    # interested in storing row-by-row differences
+                    continue
+                last_seen_idx = idx
+                self.diff_values.append(((col.name, idx),
+                                         (arra[idx], arrb[idx])))
+
+        total_values = len(self.a) * len(self.a.dtype.fields)
+        self.diff_ratio = float(self.diff_total) / float(total_values)
+
+    def _report(self):
+        if self.diff_column_count:
+            self._writeln(' Tables have different number of columns:')
+            self._writeln('  a: {}'.format(self.diff_column_count[0]))
+            self._writeln('  b: {}'.format(self.diff_column_count[1]))
+
+        if self.diff_column_names:
+            # Show columns with names unique to either table
+            for name in self.diff_column_names[0]:
+                format = self.diff_columns[0][name.lower()].format
+                self._writeln(' Extra column {} of format {} in a'.format(
+                                name, format))
+            for name in self.diff_column_names[1]:
+                format = self.diff_columns[1][name.lower()].format
+                self._writeln(' Extra column {} of format {} in b'.format(
+                                name, format))
+
+        col_attrs = dict(_COL_ATTRS)
+        # Now go through each table again and show columns with common
+        # names but other property differences...
+        for col_attr, vals in self.diff_column_attributes:
+            name, attr = col_attr
+            self._writeln(' Column {} has different {}:'.format(
+                    name, col_attrs[attr]))
+            report_diff_values(vals[0], vals[1], fileobj=self._fileobj,
+                               indent_width=self._indent + 1)
+
+        if self.diff_rows:
+            self._writeln(' Table rows differ:')
+            self._writeln('  a: {}'.format(self.diff_rows[0]))
+            self._writeln('  b: {}'.format(self.diff_rows[1]))
+            self._writeln(' No further data comparison performed.')
+            return
+
+        if not self.diff_values:
+            return
+
+        # Finally, let's go through and report column data differences:
+        for indx, values in self.diff_values:
+            self._writeln(' Column {} data differs in row {}:'.format(*indx))
+            report_diff_values(values[0], values[1], fileobj=self._fileobj,
+                               indent_width=self._indent + 1)
+
+        if self.diff_values and self.numdiffs < self.diff_total:
+            self._writeln(' ...{} additional difference(s) found.'.format(
+                                (self.diff_total - self.numdiffs)))
+
+        if self.diff_total > self.numdiffs:
+            self._writeln(' ...')
+
+        self._writeln(' {} different table data element(s) found '
+                      '({:.2%} different).'
+                      .format(self.diff_total, self.diff_ratio))
+
+
+def report_diff_keyword_attr(fileobj, attr, diffs, keyword, ind=0):
+    """
+    Write a diff between two header keyword values or comments to the specified
+    file-like object.
+    """
+
+    if keyword in diffs:
+        vals = diffs[keyword]
+        for idx, val in enumerate(vals):
+            if val is None:
+                continue
+            if idx == 0:
+                dup = ''
+            else:
+                dup = '[{}]'.format(idx + 1)
+            fileobj.write(
+                fixed_width_indent(' Keyword {:8}{} has different {}:\n'
+                                   .format(keyword, dup, attr), ind))
+            report_diff_values(val[0], val[1], fileobj=fileobj,
+                               indent_width=ind + 1)

testbed/astropy__astropy/astropy/io/fits/file.py

@@ -0,0 +1,631 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+
+import bz2
+import gzip
+import errno
+import http.client
+import mmap
+import operator
+import pathlib
+import io
+import os
+import sys
+import tempfile
+import warnings
+import zipfile
+import re
+
+from functools import reduce
+
+import numpy as np
+
+from .util import (isreadable, iswritable, isfile, fileobj_open, fileobj_name,
+                   fileobj_closed, fileobj_mode, _array_from_file,
+                   _array_to_file, _write_string)
+from astropy.utils.data import download_file, _is_url
+from astropy.utils.decorators import classproperty, deprecated_renamed_argument
+from astropy.utils.exceptions import AstropyUserWarning
+
+
+# Maps astropy.io.fits-specific file mode names to the appropriate file
+# modes to use for the underlying raw files
+IO_FITS_MODES = {
+    'readonly': 'rb',
+    'copyonwrite': 'rb',
+    'update': 'rb+',
+    'append': 'ab+',
+    'ostream': 'wb',
+    'denywrite': 'rb'}
+
+# Maps OS-level file modes to the appropriate astropy.io.fits specific mode
+# to use when given file objects but no mode specified; obviously in
+# IO_FITS_MODES there are overlaps; for example 'readonly' and 'denywrite'
+# both require the file to be opened in 'rb' mode.  But 'readonly' is the
+# default behavior for such files if not otherwise specified.
+# Note: 'ab' is only supported for 'ostream' which is output-only.
+FILE_MODES = {
+    'rb': 'readonly', 'rb+': 'update',
+    'wb': 'ostream', 'wb+': 'update',
+    'ab': 'ostream', 'ab+': 'append'}
+
+# A match indicates the file was opened in text mode, which is not allowed
+TEXT_RE = re.compile(r'^[rwa]((t?\+?)|(\+?t?))$')
+
+
+# readonly actually uses copyonwrite for mmap so that readonly without mmap and
+# with mmap still have to same behavior with regard to updating the array.  To
+# get a truly readonly mmap use denywrite
+# the name 'denywrite' comes from a deprecated flag to mmap() on Linux--it
+# should be clarified that 'denywrite' mode is not directly analogous to the
+# use of that flag; it was just taken, for lack of anything better, as a name
+# that means something like "read only" but isn't readonly.
+MEMMAP_MODES = {'readonly': mmap.ACCESS_COPY,
+                'copyonwrite': mmap.ACCESS_COPY,
+                'update': mmap.ACCESS_WRITE,
+                'append': mmap.ACCESS_COPY,
+                'denywrite': mmap.ACCESS_READ}
+
+# TODO: Eventually raise a warning, and maybe even later disable the use of
+# 'copyonwrite' and 'denywrite' modes unless memmap=True.  For now, however,
+# that would generate too many warnings for too many users.  If nothing else,
+# wait until the new logging system is in place.
+
+GZIP_MAGIC = b'\x1f\x8b\x08'
+PKZIP_MAGIC = b'\x50\x4b\x03\x04'
+BZIP2_MAGIC = b'\x42\x5a'
+
+def _normalize_fits_mode(mode):
+    if mode is not None and mode not in IO_FITS_MODES:
+        if TEXT_RE.match(mode):
+            raise ValueError(
+                "Text mode '{}' not supported: "
+                "files must be opened in binary mode".format(mode))
+        new_mode = FILE_MODES.get(mode)
+        if new_mode not in IO_FITS_MODES:
+            raise ValueError("Mode '{}' not recognized".format(mode))
+        mode = new_mode
+    return mode
+
+class _File:
+    """
+    Represents a FITS file on disk (or in some other file-like object).
+    """
+
+    @deprecated_renamed_argument('clobber', 'overwrite', '2.0')
+    def __init__(self, fileobj=None, mode=None, memmap=None, overwrite=False,
+                 cache=True):
+        self.strict_memmap = bool(memmap)
+        memmap = True if memmap is None else memmap
+
+        if fileobj is None:
+            self._file = None
+            self.closed = False
+            self.binary = True
+            self.mode = mode
+            self.memmap = memmap
+            self.compression = None
+            self.readonly = False
+            self.writeonly = False
+            self.simulateonly = True
+            self.close_on_error = False
+            return
+        else:
+            self.simulateonly = False
+            # If fileobj is of type pathlib.Path
+            if isinstance(fileobj, pathlib.Path):
+                fileobj = str(fileobj)
+            elif isinstance(fileobj, bytes):
+                # Using bytes as filename is tricky, it's deprecated for Windows
+                # in Python 3.5 (because it could lead to false-positives) but
+                # was fixed and un-deprecated in Python 3.6.
+                # However it requires that the bytes object is encoded with the
+                # file system encoding.
+                # Probably better to error out and ask for a str object instead.
+                # TODO: This could be revised when Python 3.5 support is dropped
+                # See also: https://github.com/astropy/astropy/issues/6789
+                raise TypeError("names should be `str` not `bytes`.")
+
+        # Holds mmap instance for files that use mmap
+        self._mmap = None
+
+        if mode is not None and mode not in IO_FITS_MODES:
+            raise ValueError("Mode '{}' not recognized".format(mode))
+        if isfile(fileobj):
+            objmode = _normalize_fits_mode(fileobj_mode(fileobj))
+            if mode is not None and mode != objmode:
+                raise ValueError(
+                    "Requested FITS mode '{}' not compatible with open file "
+                    "handle mode '{}'".format(mode, objmode))
+            mode = objmode
+        if mode is None:
+            mode = 'readonly'
+
+        # Handle raw URLs
+        if (isinstance(fileobj, str) and
+            mode not in ('ostream', 'append', 'update') and _is_url(fileobj)):
+            self.name = download_file(fileobj, cache=cache)
+        # Handle responses from URL requests that have already been opened
+        elif isinstance(fileobj, http.client.HTTPResponse):
+            if mode in ('ostream', 'append', 'update'):
+                raise ValueError(
+                    "Mode {} not supported for HTTPResponse".format(mode))
+            fileobj = io.BytesIO(fileobj.read())
+        else:
+            self.name = fileobj_name(fileobj)
+
+        self.closed = False
+        self.binary = True
+        self.mode = mode
+        self.memmap = memmap
+
+        # Underlying fileobj is a file-like object, but an actual file object
+        self.file_like = False
+
+        # Should the object be closed on error: see
+        # https://github.com/astropy/astropy/issues/6168
+        self.close_on_error = False
+
+        # More defaults to be adjusted below as necessary
+        self.compression = None
+        self.readonly = False
+        self.writeonly = False
+
+        # Initialize the internal self._file object
+        if isfile(fileobj):
+            self._open_fileobj(fileobj, mode, overwrite)
+        elif isinstance(fileobj, str):
+            self._open_filename(fileobj, mode, overwrite)
+        else:
+            self._open_filelike(fileobj, mode, overwrite)
+
+        self.fileobj_mode = fileobj_mode(self._file)
+
+        if isinstance(fileobj, gzip.GzipFile):
+            self.compression = 'gzip'
+        elif isinstance(fileobj, zipfile.ZipFile):
+            # Reading from zip files is supported but not writing (yet)
+            self.compression = 'zip'
+        elif isinstance(fileobj, bz2.BZ2File):
+            self.compression = 'bzip2'
+
+        if (mode in ('readonly', 'copyonwrite', 'denywrite') or
+                (self.compression and mode == 'update')):
+            self.readonly = True
+        elif (mode == 'ostream' or
+                (self.compression and mode == 'append')):
+            self.writeonly = True
+
+        # For 'ab+' mode, the pointer is at the end after the open in
+        # Linux, but is at the beginning in Solaris.
+        if (mode == 'ostream' or self.compression or
+            not hasattr(self._file, 'seek')):
+            # For output stream start with a truncated file.
+            # For compressed files we can't really guess at the size
+            self.size = 0
+        else:
+            pos = self._file.tell()
+            self._file.seek(0, 2)
+            self.size = self._file.tell()
+            self._file.seek(pos)
+
+        if self.memmap:
+            if not isfile(self._file):
+                self.memmap = False
+            elif not self.readonly and not self._mmap_available:
+                # Test mmap.flush--see
+                # https://github.com/astropy/astropy/issues/968
+                self.memmap = False
+
+    def __repr__(self):
+        return '<{}.{} {}>'.format(self.__module__, self.__class__.__name__,
+                                   self._file)
+
+    # Support the 'with' statement
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    def readable(self):
+        if self.writeonly:
+            return False
+        return isreadable(self._file)
+
+    def read(self, size=None):
+        if not hasattr(self._file, 'read'):
+            raise EOFError
+        try:
+            return self._file.read(size)
+        except OSError:
+            # On some versions of Python, it appears, GzipFile will raise an
+            # OSError if you try to read past its end (as opposed to just
+            # returning '')
+            if self.compression == 'gzip':
+                return ''
+            raise
+
+    def readarray(self, size=None, offset=0, dtype=np.uint8, shape=None):
+        """
+        Similar to file.read(), but returns the contents of the underlying
+        file as a numpy array (or mmap'd array if memmap=True) rather than a
+        string.
+
+        Usually it's best not to use the `size` argument with this method, but
+        it's provided for compatibility.
+        """
+
+        if not hasattr(self._file, 'read'):
+            raise EOFError
+
+        if not isinstance(dtype, np.dtype):
+            dtype = np.dtype(dtype)
+
+        if size and size % dtype.itemsize != 0:
+            raise ValueError('size {} not a multiple of {}'.format(size, dtype))
+
+        if isinstance(shape, int):
+            shape = (shape,)
+
+        if not (size or shape):
+            warnings.warn('No size or shape given to readarray(); assuming a '
+                          'shape of (1,)', AstropyUserWarning)
+            shape = (1,)
+
+        if size and not shape:
+            shape = (size // dtype.itemsize,)
+
+        if size and shape:
+            actualsize = np.prod(shape) * dtype.itemsize
+
+            if actualsize > size:
+                raise ValueError('size {} is too few bytes for a {} array of '
+                                 '{}'.format(size, shape, dtype))
+            elif actualsize < size:
+                raise ValueError('size {} is too many bytes for a {} array of '
+                                 '{}'.format(size, shape, dtype))
+
+        filepos = self._file.tell()
+
+        try:
+            if self.memmap:
+                if self._mmap is None:
+                    # Instantiate Memmap array of the file offset at 0 (so we
+                    # can return slices of it to offset anywhere else into the
+                    # file)
+                    access_mode = MEMMAP_MODES[self.mode]
+
+                    # For reasons unknown the file needs to point to (near)
+                    # the beginning or end of the file. No idea how close to
+                    # the beginning or end.
+                    # If I had to guess there is some bug in the mmap module
+                    # of CPython or perhaps in microsoft's underlying code
+                    # for generating the mmap.
+                    self._file.seek(0, 0)
+                    # This would also work:
+                    # self._file.seek(0, 2)   # moves to the end
+                    try:
+                        self._mmap = mmap.mmap(self._file.fileno(), 0,
+                                               access=access_mode,
+                                               offset=0)
+                    except OSError as exc:
+                        # NOTE: mode='readonly' results in the memory-mapping
+                        # using the ACCESS_COPY mode in mmap so that users can
+                        # modify arrays. However, on some systems, the OS raises
+                        # a '[Errno 12] Cannot allocate memory' OSError if the
+                        # address space is smaller than the file. The solution
+                        # is to open the file in mode='denywrite', which at
+                        # least allows the file to be opened even if the
+                        # resulting arrays will be truly read-only.
+                        if exc.errno == errno.ENOMEM and self.mode == 'readonly':
+                            warnings.warn("Could not memory map array with "
+                                          "mode='readonly', falling back to "
+                                          "mode='denywrite', which means that "
+                                          "the array will be read-only",
+                                          AstropyUserWarning)
+                            self._mmap = mmap.mmap(self._file.fileno(), 0,
+                                                   access=MEMMAP_MODES['denywrite'],
+                                                   offset=0)
+                        else:
+                            raise
+
+                return np.ndarray(shape=shape, dtype=dtype, offset=offset,
+                                  buffer=self._mmap)
+            else:
+                count = reduce(operator.mul, shape)
+                self._file.seek(offset)
+                data = _array_from_file(self._file, dtype, count)
+                data.shape = shape
+                return data
+        finally:
+            # Make sure we leave the file in the position we found it; on
+            # some platforms (e.g. Windows) mmaping a file handle can also
+            # reset its file pointer
+            self._file.seek(filepos)
+
+    def writable(self):
+        if self.readonly:
+            return False
+        return iswritable(self._file)
+
+    def write(self, string):
+        if hasattr(self._file, 'write'):
+            _write_string(self._file, string)
+
+    def writearray(self, array):
+        """
+        Similar to file.write(), but writes a numpy array instead of a string.
+
+        Also like file.write(), a flush() or close() may be needed before
+        the file on disk reflects the data written.
+        """
+
+        if hasattr(self._file, 'write'):
+            _array_to_file(array, self._file)
+
+    def flush(self):
+        if hasattr(self._file, 'flush'):
+            self._file.flush()
+
+    def seek(self, offset, whence=0):
+        if not hasattr(self._file, 'seek'):
+            return
+        self._file.seek(offset, whence)
+        pos = self._file.tell()
+        if self.size and pos > self.size:
+            warnings.warn('File may have been truncated: actual file length '
+                          '({}) is smaller than the expected size ({})'
+                          .format(self.size, pos), AstropyUserWarning)
+
+    def tell(self):
+        if not hasattr(self._file, 'tell'):
+            raise EOFError
+        return self._file.tell()
+
+    def truncate(self, size=None):
+        if hasattr(self._file, 'truncate'):
+            self._file.truncate(size)
+
+    def close(self):
+        """
+        Close the 'physical' FITS file.
+        """
+
+        if hasattr(self._file, 'close'):
+            self._file.close()
+
+        self._maybe_close_mmap()
+        # Set self._memmap to None anyways since no new .data attributes can be
+        # loaded after the file is closed
+        self._mmap = None
+
+        self.closed = True
+        self.close_on_error = False
+
+    def _maybe_close_mmap(self, refcount_delta=0):
+        """
+        When mmap is in use these objects hold a reference to the mmap of the
+        file (so there is only one, shared by all HDUs that reference this
+        file).
+
+        This will close the mmap if there are no arrays referencing it.
+        """
+
+        if (self._mmap is not None and
+                sys.getrefcount(self._mmap) == 2 + refcount_delta):
+            self._mmap.close()
+            self._mmap = None
+
+    def _overwrite_existing(self, overwrite, fileobj, closed):
+        """Overwrite an existing file if ``overwrite`` is ``True``, otherwise
+        raise an OSError.  The exact behavior of this method depends on the
+        _File object state and is only meant for use within the ``_open_*``
+        internal methods.
+        """
+
+        # The file will be overwritten...
+        if ((self.file_like and hasattr(fileobj, 'len') and fileobj.len > 0) or
+            (os.path.exists(self.name) and os.path.getsize(self.name) != 0)):
+            if overwrite:
+                if self.file_like and hasattr(fileobj, 'truncate'):
+                    fileobj.truncate(0)
+                else:
+                    if not closed:
+                        fileobj.close()
+                    os.remove(self.name)
+            else:
+                raise OSError("File {!r} already exists.".format(self.name))
+
+    def _try_read_compressed(self, obj_or_name, magic, mode, ext=''):
+        """Attempt to determine if the given file is compressed"""
+        if ext == '.gz' or magic.startswith(GZIP_MAGIC):
+            if mode == 'append':
+                raise OSError("'append' mode is not supported with gzip files."
+                              "Use 'update' mode instead")
+            # Handle gzip files
+            kwargs = dict(mode=IO_FITS_MODES[mode])
+            if isinstance(obj_or_name, str):
+                kwargs['filename'] = obj_or_name
+            else:
+                kwargs['fileobj'] = obj_or_name
+            self._file = gzip.GzipFile(**kwargs)
+            self.compression = 'gzip'
+        elif ext == '.zip' or magic.startswith(PKZIP_MAGIC):
+            # Handle zip files
+            self._open_zipfile(self.name, mode)
+            self.compression = 'zip'
+        elif ext == '.bz2' or magic.startswith(BZIP2_MAGIC):
+            # Handle bzip2 files
+            if mode in ['update', 'append']:
+                raise OSError("update and append modes are not supported "
+                              "with bzip2 files")
+            # bzip2 only supports 'w' and 'r' modes
+            bzip2_mode = 'w' if mode == 'ostream' else 'r'
+            self._file = bz2.BZ2File(obj_or_name, mode=bzip2_mode)
+            self.compression = 'bzip2'
+        return self.compression is not None
+
+    def _open_fileobj(self, fileobj, mode, overwrite):
+        """Open a FITS file from a file object (including compressed files)."""
+
+        closed = fileobj_closed(fileobj)
+        fmode = fileobj_mode(fileobj) or IO_FITS_MODES[mode]
+
+        if mode == 'ostream':
+            self._overwrite_existing(overwrite, fileobj, closed)
+
+        if not closed:
+            self._file = fileobj
+        elif isfile(fileobj):
+            self._file = fileobj_open(self.name, IO_FITS_MODES[mode])
+
+        # Attempt to determine if the file represented by the open file object
+        # is compressed
+        try:
+            # We need to account for the possibility that the underlying file
+            # handle may have been opened with either 'ab' or 'ab+', which
+            # means that the current file position is at the end of the file.
+            if mode in ['ostream', 'append']:
+                self._file.seek(0)
+            magic = self._file.read(4)
+            # No matter whether the underlying file was opened with 'ab' or
+            # 'ab+', we need to return to the beginning of the file in order
+            # to properly process the FITS header (and handle the possibility
+            # of a compressed file).
+            self._file.seek(0)
+        except (OSError,OSError):
+            return
+
+        self._try_read_compressed(fileobj, magic, mode)
+
+    def _open_filelike(self, fileobj, mode, overwrite):
+        """Open a FITS file from a file-like object, i.e. one that has
+        read and/or write methods.
+        """
+
+        self.file_like = True
+        self._file = fileobj
+
+        if fileobj_closed(fileobj):
+            raise OSError("Cannot read from/write to a closed file-like "
+                          "object ({!r}).".format(fileobj))
+
+        if isinstance(fileobj, zipfile.ZipFile):
+            self._open_zipfile(fileobj, mode)
+            # We can bypass any additional checks at this point since now
+            # self._file points to the temp file extracted from the zip
+            return
+
+        # If there is not seek or tell methods then set the mode to
+        # output streaming.
+        if (not hasattr(self._file, 'seek') or
+            not hasattr(self._file, 'tell')):
+            self.mode = mode = 'ostream'
+
+        if mode == 'ostream':
+            self._overwrite_existing(overwrite, fileobj, False)
+
+        # Any "writeable" mode requires a write() method on the file object
+        if (self.mode in ('update', 'append', 'ostream') and
+            not hasattr(self._file, 'write')):
+            raise OSError("File-like object does not have a 'write' "
+                          "method, required for mode '{}'.".format(self.mode))
+
+        # Any mode except for 'ostream' requires readability
+        if self.mode != 'ostream' and not hasattr(self._file, 'read'):
+            raise OSError("File-like object does not have a 'read' "
+                          "method, required for mode {!r}.".format(self.mode))
+
+    def _open_filename(self, filename, mode, overwrite):
+        """Open a FITS file from a filename string."""
+
+        if mode == 'ostream':
+            self._overwrite_existing(overwrite, None, True)
+
+        if os.path.exists(self.name):
+            with fileobj_open(self.name, 'rb') as f:
+                magic = f.read(4)
+        else:
+            magic = b''
+
+        ext = os.path.splitext(self.name)[1]
+
+        if not self._try_read_compressed(self.name, magic, mode, ext=ext):
+            self._file = fileobj_open(self.name, IO_FITS_MODES[mode])
+            self.close_on_error = True
+
+        # Make certain we're back at the beginning of the file
+        # BZ2File does not support seek when the file is open for writing, but
+        # when opening a file for write, bz2.BZ2File always truncates anyway.
+        if not (isinstance(self._file, bz2.BZ2File) and mode == 'ostream'):
+            self._file.seek(0)
+
+    @classproperty(lazy=True)
+    def _mmap_available(cls):
+        """Tests that mmap, and specifically mmap.flush works.  This may
+        be the case on some uncommon platforms (see
+        https://github.com/astropy/astropy/issues/968).
+
+        If mmap.flush is found not to work, ``self.memmap = False`` is
+        set and a warning is issued.
+        """
+
+        tmpfd, tmpname = tempfile.mkstemp()
+        try:
+            # Windows does not allow mappings on empty files
+            os.write(tmpfd, b' ')
+            os.fsync(tmpfd)
+            try:
+                mm = mmap.mmap(tmpfd, 1, access=mmap.ACCESS_WRITE)
+            except OSError as exc:
+                warnings.warn('Failed to create mmap: {}; mmap use will be '
+                              'disabled'.format(str(exc)), AstropyUserWarning)
+                del exc
+                return False
+            try:
+                mm.flush()
+            except OSError:
+                warnings.warn('mmap.flush is unavailable on this platform; '
+                              'using mmap in writeable mode will be disabled',
+                              AstropyUserWarning)
+                return False
+            finally:
+                mm.close()
+        finally:
+            os.close(tmpfd)
+            os.remove(tmpname)
+
+        return True
+
+    def _open_zipfile(self, fileobj, mode):
+        """Limited support for zipfile.ZipFile objects containing a single
+        a file.  Allows reading only for now by extracting the file to a
+        tempfile.
+        """
+
+        if mode in ('update', 'append'):
+            raise OSError(
+                  "Writing to zipped fits files is not currently "
+                  "supported")
+
+        if not isinstance(fileobj, zipfile.ZipFile):
+            zfile = zipfile.ZipFile(fileobj)
+            close = True
+        else:
+            zfile = fileobj
+            close = False
+
+        namelist = zfile.namelist()
+        if len(namelist) != 1:
+            raise OSError(
+              "Zip files with multiple members are not supported.")
+        self._file = tempfile.NamedTemporaryFile(suffix='.fits')
+        self._file.write(zfile.read(namelist[0]))
+
+        if close:
+            zfile.close()
+        # We just wrote the contents of the first file in the archive to a new
+        # temp file, which now serves as our underlying file object. So it's
+        # necessary to reset the position back to the beginning
+        self._file.seek(0)

testbed/astropy__astropy/astropy/io/fits/fitsrec.py

@@ -0,0 +1,1338 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import copy
+import operator
+import warnings
+import weakref
+
+from contextlib import suppress
+from functools import reduce
+
+import numpy as np
+
+from numpy import char as chararray
+
+from .column import (ASCIITNULL, FITS2NUMPY, ASCII2NUMPY, ASCII2STR, ColDefs,
+                     _AsciiColDefs, _FormatX, _FormatP, _VLF, _get_index,
+                     _wrapx, _unwrapx, _makep, Delayed)
+from .util import decode_ascii, encode_ascii, _rstrip_inplace
+from astropy.utils import lazyproperty
+
+
+class FITS_record:
+    """
+    FITS record class.
+
+    `FITS_record` is used to access records of the `FITS_rec` object.
+    This will allow us to deal with scaled columns.  It also handles
+    conversion/scaling of columns in ASCII tables.  The `FITS_record`
+    class expects a `FITS_rec` object as input.
+    """
+
+    def __init__(self, input, row=0, start=None, end=None, step=None,
+                 base=None, **kwargs):
+        """
+        Parameters
+        ----------
+        input : array
+           The array to wrap.
+
+        row : int, optional
+           The starting logical row of the array.
+
+        start : int, optional
+           The starting column in the row associated with this object.
+           Used for subsetting the columns of the `FITS_rec` object.
+
+        end : int, optional
+           The ending column in the row associated with this object.
+           Used for subsetting the columns of the `FITS_rec` object.
+        """
+
+        self.array = input
+        self.row = row
+        if base:
+            width = len(base)
+        else:
+            width = self.array._nfields
+
+        s = slice(start, end, step).indices(width)
+        self.start, self.end, self.step = s
+        self.base = base
+
+    def __getitem__(self, key):
+        if isinstance(key, str):
+            indx = _get_index(self.array.names, key)
+
+            if indx < self.start or indx > self.end - 1:
+                raise KeyError("Key '{}' does not exist.".format(key))
+        elif isinstance(key, slice):
+            return type(self)(self.array, self.row, key.start, key.stop,
+                              key.step, self)
+        else:
+            indx = self._get_index(key)
+
+            if indx > self.array._nfields - 1:
+                raise IndexError('Index out of bounds')
+
+        return self.array.field(indx)[self.row]
+
+    def __setitem__(self, key, value):
+        if isinstance(key, str):
+            indx = _get_index(self.array.names, key)
+
+            if indx < self.start or indx > self.end - 1:
+                raise KeyError("Key '{}' does not exist.".format(key))
+        elif isinstance(key, slice):
+            for indx in range(slice.start, slice.stop, slice.step):
+                indx = self._get_indx(indx)
+                self.array.field(indx)[self.row] = value
+        else:
+            indx = self._get_index(key)
+            if indx > self.array._nfields - 1:
+                raise IndexError('Index out of bounds')
+
+        self.array.field(indx)[self.row] = value
+
+    def __len__(self):
+        return len(range(self.start, self.end, self.step))
+
+    def __repr__(self):
+        """
+        Display a single row.
+        """
+
+        outlist = []
+        for idx in range(len(self)):
+            outlist.append(repr(self[idx]))
+        return '({})'.format(', '.join(outlist))
+
+    def field(self, field):
+        """
+        Get the field data of the record.
+        """
+
+        return self.__getitem__(field)
+
+    def setfield(self, field, value):
+        """
+        Set the field data of the record.
+        """
+
+        self.__setitem__(field, value)
+
+    @lazyproperty
+    def _bases(self):
+        bases = [weakref.proxy(self)]
+        base = self.base
+        while base:
+            bases.append(base)
+            base = base.base
+        return bases
+
+    def _get_index(self, indx):
+        indices = np.ogrid[:self.array._nfields]
+        for base in reversed(self._bases):
+            if base.step < 1:
+                s = slice(base.start, None, base.step)
+            else:
+                s = slice(base.start, base.end, base.step)
+            indices = indices[s]
+        return indices[indx]
+
+
+class FITS_rec(np.recarray):
+    """
+    FITS record array class.
+
+    `FITS_rec` is the data part of a table HDU's data part.  This is a layer
+    over the `~numpy.recarray`, so we can deal with scaled columns.
+
+    It inherits all of the standard methods from `numpy.ndarray`.
+    """
+
+    _record_type = FITS_record
+    _character_as_bytes = False
+
+    def __new__(subtype, input):
+        """
+        Construct a FITS record array from a recarray.
+        """
+
+        # input should be a record array
+        if input.dtype.subdtype is None:
+            self = np.recarray.__new__(subtype, input.shape, input.dtype,
+                                       buf=input.data)
+        else:
+            self = np.recarray.__new__(subtype, input.shape, input.dtype,
+                                       buf=input.data, strides=input.strides)
+
+        self._init()
+        if self.dtype.fields:
+            self._nfields = len(self.dtype.fields)
+
+        return self
+
+    def __setstate__(self, state):
+        meta = state[-1]
+        column_state = state[-2]
+        state = state[:-2]
+
+        super().__setstate__(state)
+
+        self._col_weakrefs = weakref.WeakSet()
+
+        for attr, value in zip(meta, column_state):
+            setattr(self, attr, value)
+
+    def __reduce__(self):
+        """
+        Return a 3-tuple for pickling a FITS_rec. Use the super-class
+        functionality but then add in a tuple of FITS_rec-specific
+        values that get used in __setstate__.
+        """
+
+        reconst_func, reconst_func_args, state = super().__reduce__()
+
+        # Define FITS_rec-specific attrs that get added to state
+        column_state = []
+        meta = []
+
+        for attrs in ['_converted', '_heapoffset', '_heapsize', '_nfields',
+                      '_gap', '_uint', 'parnames', '_coldefs']:
+
+            with suppress(AttributeError):
+                # _coldefs can be Delayed, and file objects cannot be
+                # picked, it needs to be deepcopied first
+                if attrs == '_coldefs':
+                    column_state.append(self._coldefs.__deepcopy__(None))
+                else:
+                    column_state.append(getattr(self, attrs))
+                meta.append(attrs)
+
+        state = state + (column_state, meta)
+
+        return reconst_func, reconst_func_args, state
+
+    def __array_finalize__(self, obj):
+        if obj is None:
+            return
+
+        if isinstance(obj, FITS_rec):
+            self._character_as_bytes = obj._character_as_bytes
+
+        if isinstance(obj, FITS_rec) and obj.dtype == self.dtype:
+            self._converted = obj._converted
+            self._heapoffset = obj._heapoffset
+            self._heapsize = obj._heapsize
+            self._col_weakrefs = obj._col_weakrefs
+            self._coldefs = obj._coldefs
+            self._nfields = obj._nfields
+            self._gap = obj._gap
+            self._uint = obj._uint
+        elif self.dtype.fields is not None:
+            # This will allow regular ndarrays with fields, rather than
+            # just other FITS_rec objects
+            self._nfields = len(self.dtype.fields)
+            self._converted = {}
+
+            self._heapoffset = getattr(obj, '_heapoffset', 0)
+            self._heapsize = getattr(obj, '_heapsize', 0)
+
+            self._gap = getattr(obj, '_gap', 0)
+            self._uint = getattr(obj, '_uint', False)
+            self._col_weakrefs = weakref.WeakSet()
+            self._coldefs = ColDefs(self)
+
+            # Work around chicken-egg problem.  Column.array relies on the
+            # _coldefs attribute to set up ref back to parent FITS_rec; however
+            # in the above line the self._coldefs has not been assigned yet so
+            # this fails.  This patches that up...
+            for col in self._coldefs:
+                del col.array
+                col._parent_fits_rec = weakref.ref(self)
+        else:
+            self._init()
+
+    def _init(self):
+        """Initializes internal attributes specific to FITS-isms."""
+
+        self._nfields = 0
+        self._converted = {}
+        self._heapoffset = 0
+        self._heapsize = 0
+        self._col_weakrefs = weakref.WeakSet()
+        self._coldefs = None
+        self._gap = 0
+        self._uint = False
+
+    @classmethod
+    def from_columns(cls, columns, nrows=0, fill=False, character_as_bytes=False):
+        """
+        Given a `ColDefs` object of unknown origin, initialize a new `FITS_rec`
+        object.
+
+        .. note::
+
+            This was originally part of the ``new_table`` function in the table
+            module but was moved into a class method since most of its
+            functionality always had more to do with initializing a `FITS_rec`
+            object than anything else, and much of it also overlapped with
+            ``FITS_rec._scale_back``.
+
+        Parameters
+        ----------
+        columns : sequence of `Column` or a `ColDefs`
+            The columns from which to create the table data.  If these
+            columns have data arrays attached that data may be used in
+            initializing the new table.  Otherwise the input columns
+            will be used as a template for a new table with the requested
+            number of rows.
+
+        nrows : int
+            Number of rows in the new table.  If the input columns have data
+            associated with them, the size of the largest input column is used.
+            Otherwise the default is 0.
+
+        fill : bool
+            If `True`, will fill all cells with zeros or blanks.  If
+            `False`, copy the data from input, undefined cells will still
+            be filled with zeros/blanks.
+        """
+
+        if not isinstance(columns, ColDefs):
+            columns = ColDefs(columns)
+
+        # read the delayed data
+        for column in columns:
+            arr = column.array
+            if isinstance(arr, Delayed):
+                if arr.hdu.data is None:
+                    column.array = None
+                else:
+                    column.array = _get_recarray_field(arr.hdu.data,
+                                                       arr.field)
+        # Reset columns._arrays (which we may want to just do away with
+        # altogether
+        del columns._arrays
+
+        # use the largest column shape as the shape of the record
+        if nrows == 0:
+            for arr in columns._arrays:
+                if arr is not None:
+                    dim = arr.shape[0]
+                else:
+                    dim = 0
+                if dim > nrows:
+                    nrows = dim
+
+        raw_data = np.empty(columns.dtype.itemsize * nrows, dtype=np.uint8)
+        raw_data.fill(ord(columns._padding_byte))
+        data = np.recarray(nrows, dtype=columns.dtype, buf=raw_data).view(cls)
+        data._character_as_bytes = character_as_bytes
+
+        # Make sure the data is a listener for changes to the columns
+        columns._add_listener(data)
+
+        # Previously this assignment was made from hdu.columns, but that's a
+        # bug since if a _TableBaseHDU has a FITS_rec in its .data attribute
+        # the _TableBaseHDU.columns property is actually returned from
+        # .data._coldefs, so this assignment was circular!  Don't make that
+        # mistake again.
+        # All of this is an artifact of the fragility of the FITS_rec class,
+        # and that it can't just be initialized by columns...
+        data._coldefs = columns
+
+        # If fill is True we don't copy anything from the column arrays.  We're
+        # just using them as a template, and returning a table filled with
+        # zeros/blanks
+        if fill:
+            return data
+
+        # Otherwise we have to fill the recarray with data from the input
+        # columns
+        for idx, column in enumerate(columns):
+            # For each column in the ColDef object, determine the number of
+            # rows in that column.  This will be either the number of rows in
+            # the ndarray associated with the column, or the number of rows
+            # given in the call to this function, which ever is smaller.  If
+            # the input FILL argument is true, the number of rows is set to
+            # zero so that no data is copied from the original input data.
+            arr = column.array
+
+            if arr is None:
+                array_size = 0
+            else:
+                array_size = len(arr)
+
+            n = min(array_size, nrows)
+
+            # TODO: At least *some* of this logic is mostly redundant with the
+            # _convert_foo methods in this class; see if we can eliminate some
+            # of that duplication.
+
+            if not n:
+                # The input column had an empty array, so just use the fill
+                # value
+                continue
+
+            field = _get_recarray_field(data, idx)
+            name = column.name
+            fitsformat = column.format
+            recformat = fitsformat.recformat
+
+            outarr = field[:n]
+            inarr = arr[:n]
+
+            if isinstance(recformat, _FormatX):
+                # Data is a bit array
+                if inarr.shape[-1] == recformat.repeat:
+                    _wrapx(inarr, outarr, recformat.repeat)
+                    continue
+            elif isinstance(recformat, _FormatP):
+                data._cache_field(name, _makep(inarr, field, recformat,
+                                               nrows=nrows))
+                continue
+            # TODO: Find a better way of determining that the column is meant
+            # to be FITS L formatted
+            elif recformat[-2:] == FITS2NUMPY['L'] and inarr.dtype == bool:
+                # column is boolean
+                # The raw data field should be filled with either 'T' or 'F'
+                # (not 0).  Use 'F' as a default
+                field[:] = ord('F')
+                # Also save the original boolean array in data._converted so
+                # that it doesn't have to be re-converted
+                converted = np.zeros(field.shape, dtype=bool)
+                converted[:n] = inarr
+                data._cache_field(name, converted)
+                # TODO: Maybe this step isn't necessary at all if _scale_back
+                # will handle it?
+                inarr = np.where(inarr == np.False_, ord('F'), ord('T'))
+            elif (columns[idx]._physical_values and
+                    columns[idx]._pseudo_unsigned_ints):
+                # Temporary hack...
+                bzero = column.bzero
+                converted = np.zeros(field.shape, dtype=inarr.dtype)
+                converted[:n] = inarr
+                data._cache_field(name, converted)
+                if n < nrows:
+                    # Pre-scale rows below the input data
+                    field[n:] = -bzero
+
+                inarr = inarr - bzero
+            elif isinstance(columns, _AsciiColDefs):
+                # Regardless whether the format is character or numeric, if the
+                # input array contains characters then it's already in the raw
+                # format for ASCII tables
+                if fitsformat._pseudo_logical:
+                    # Hack to support converting from 8-bit T/F characters
+                    # Normally the column array is a chararray of 1 character
+                    # strings, but we need to view it as a normal ndarray of
+                    # 8-bit ints to fill it with ASCII codes for 'T' and 'F'
+                    outarr = field.view(np.uint8, np.ndarray)[:n]
+                elif arr.dtype.kind not in ('S', 'U'):
+                    # Set up views of numeric columns with the appropriate
+                    # numeric dtype
+                    # Fill with the appropriate blanks for the column format
+                    data._cache_field(name, np.zeros(nrows, dtype=arr.dtype))
+                    outarr = data._converted[name][:n]
+
+                outarr[:] = inarr
+                continue
+
+            if inarr.shape != outarr.shape:
+                if (inarr.dtype.kind == outarr.dtype.kind and
+                        inarr.dtype.kind in ('U', 'S') and
+                        inarr.dtype != outarr.dtype):
+
+                    inarr_rowsize = inarr[0].size
+                    inarr = inarr.flatten().view(outarr.dtype)
+
+                # This is a special case to handle input arrays with
+                # non-trivial TDIMn.
+                # By design each row of the outarray is 1-D, while each row of
+                # the input array may be n-D
+                if outarr.ndim > 1:
+                    # The normal case where the first dimension is the rows
+                    inarr_rowsize = inarr[0].size
+                    inarr = inarr.reshape(n, inarr_rowsize)
+                    outarr[:, :inarr_rowsize] = inarr
+                else:
+                    # Special case for strings where the out array only has one
+                    # dimension (the second dimension is rolled up into the
+                    # strings
+                    outarr[:n] = inarr.ravel()
+            else:
+                outarr[:] = inarr
+
+        # Now replace the original column array references with the new
+        # fields
+        # This is required to prevent the issue reported in
+        # https://github.com/spacetelescope/PyFITS/issues/99
+        for idx in range(len(columns)):
+            columns._arrays[idx] = data.field(idx)
+
+        return data
+
+    def __repr__(self):
+        # Force use of the normal ndarray repr (rather than the new
+        # one added for recarray in Numpy 1.10) for backwards compat
+        return np.ndarray.__repr__(self)
+
+    def __getitem__(self, key):
+        if self._coldefs is None:
+            return super().__getitem__(key)
+
+        if isinstance(key, str):
+            return self.field(key)
+
+        # Have to view as a recarray then back as a FITS_rec, otherwise the
+        # circular reference fix/hack in FITS_rec.field() won't preserve
+        # the slice.
+        out = self.view(np.recarray)[key]
+        if type(out) is not np.recarray:
+            # Oops, we got a single element rather than a view. In that case,
+            # return a Record, which has no __getstate__ and is more efficient.
+            return self._record_type(self, key)
+
+        # We got a view; change it back to our class, and add stuff
+        out = out.view(type(self))
+        out._coldefs = ColDefs(self._coldefs)
+        arrays = []
+        out._converted = {}
+        for idx, name in enumerate(self._coldefs.names):
+            #
+            # Store the new arrays for the _coldefs object
+            #
+            arrays.append(self._coldefs._arrays[idx][key])
+
+            # Ensure that the sliced FITS_rec will view the same scaled
+            # columns as the original; this is one of the few cases where
+            # it is not necessary to use _cache_field()
+            if name in self._converted:
+                dummy = self._converted[name]
+                field = np.ndarray.__getitem__(dummy, key)
+                out._converted[name] = field
+
+        out._coldefs._arrays = arrays
+        return out
+
+    def __setitem__(self, key, value):
+        if self._coldefs is None:
+            return super().__setitem__(key, value)
+
+        if isinstance(key, str):
+            self[key][:] = value
+            return
+
+        if isinstance(key, slice):
+            end = min(len(self), key.stop or len(self))
+            end = max(0, end)
+            start = max(0, key.start or 0)
+            end = min(end, start + len(value))
+
+            for idx in range(start, end):
+                self.__setitem__(idx, value[idx - start])
+            return
+
+        if isinstance(value, FITS_record):
+            for idx in range(self._nfields):
+                self.field(self.names[idx])[key] = value.field(self.names[idx])
+        elif isinstance(value, (tuple, list, np.void)):
+            if self._nfields == len(value):
+                for idx in range(self._nfields):
+                    self.field(idx)[key] = value[idx]
+            else:
+                raise ValueError('Input tuple or list required to have {} '
+                                 'elements.'.format(self._nfields))
+        else:
+            raise TypeError('Assignment requires a FITS_record, tuple, or '
+                            'list as input.')
+
+    def _ipython_key_completions_(self):
+        return self.names
+
+    def copy(self, order='C'):
+        """
+        The Numpy documentation lies; `numpy.ndarray.copy` is not equivalent to
+        `numpy.copy`.  Differences include that it re-views the copied array as
+        self's ndarray subclass, as though it were taking a slice; this means
+        ``__array_finalize__`` is called and the copy shares all the array
+        attributes (including ``._converted``!).  So we need to make a deep
+        copy of all those attributes so that the two arrays truly do not share
+        any data.
+        """
+
+        new = super().copy(order=order)
+
+        new.__dict__ = copy.deepcopy(self.__dict__)
+        return new
+
+    @property
+    def columns(self):
+        """
+        A user-visible accessor for the coldefs.
+
+        See https://aeon.stsci.edu/ssb/trac/pyfits/ticket/44
+        """
+
+        return self._coldefs
+
+    @property
+    def _coldefs(self):
+        # This used to be a normal internal attribute, but it was changed to a
+        # property as a quick and transparent way to work around the reference
+        # leak bug fixed in https://github.com/astropy/astropy/pull/4539
+        #
+        # See the long comment in the Column.array property for more details
+        # on this.  But in short, FITS_rec now has a ._col_weakrefs attribute
+        # which is a WeakSet of weakrefs to each Column in _coldefs.
+        #
+        # So whenever ._coldefs is set we also add each Column in the ColDefs
+        # to the weakrefs set.  This is an easy way to find out if a Column has
+        # any references to it external to the FITS_rec (i.e. a user assigned a
+        # column to a variable).  If the column is still in _col_weakrefs then
+        # there are other references to it external to this FITS_rec.  We use
+        # that information in __del__ to save off copies of the array data
+        # for those columns to their Column.array property before our memory
+        # is freed.
+        return self.__dict__.get('_coldefs')
+
+    @_coldefs.setter
+    def _coldefs(self, cols):
+        self.__dict__['_coldefs'] = cols
+        if isinstance(cols, ColDefs):
+            for col in cols.columns:
+                self._col_weakrefs.add(col)
+
+    @_coldefs.deleter
+    def _coldefs(self):
+        try:
+            del self.__dict__['_coldefs']
+        except KeyError as exc:
+            raise AttributeError(exc.args[0])
+
+    def __del__(self):
+        try:
+            del self._coldefs
+            if self.dtype.fields is not None:
+                for col in self._col_weakrefs:
+
+                    if col.array is not None:
+                        col.array = col.array.copy()
+
+        # See issues #4690 and #4912
+        except (AttributeError, TypeError):  # pragma: no cover
+            pass
+
+    @property
+    def names(self):
+        """List of column names."""
+
+        if self.dtype.fields:
+            return list(self.dtype.names)
+        elif getattr(self, '_coldefs', None) is not None:
+            return self._coldefs.names
+        else:
+            return None
+
+    @property
+    def formats(self):
+        """List of column FITS formats."""
+
+        if getattr(self, '_coldefs', None) is not None:
+            return self._coldefs.formats
+
+        return None
+
+    @property
+    def _raw_itemsize(self):
+        """
+        Returns the size of row items that would be written to the raw FITS
+        file, taking into account the possibility of unicode columns being
+        compactified.
+
+        Currently for internal use only.
+        """
+
+        if _has_unicode_fields(self):
+            total_itemsize = 0
+            for field in self.dtype.fields.values():
+                itemsize = field[0].itemsize
+                if field[0].kind == 'U':
+                    itemsize = itemsize // 4
+                total_itemsize += itemsize
+            return total_itemsize
+        else:
+            # Just return the normal itemsize
+            return self.itemsize
+
+    def field(self, key):
+        """
+        A view of a `Column`'s data as an array.
+        """
+
+        # NOTE: The *column* index may not be the same as the field index in
+        # the recarray, if the column is a phantom column
+        column = self.columns[key]
+        name = column.name
+        format = column.format
+
+        if format.dtype.itemsize == 0:
+            warnings.warn(
+                'Field {!r} has a repeat count of 0 in its format code, '
+                'indicating an empty field.'.format(key))
+            return np.array([], dtype=format.dtype)
+
+        # If field's base is a FITS_rec, we can run into trouble because it
+        # contains a reference to the ._coldefs object of the original data;
+        # this can lead to a circular reference; see ticket #49
+        base = self
+        while (isinstance(base, FITS_rec) and
+                isinstance(base.base, np.recarray)):
+            base = base.base
+        # base could still be a FITS_rec in some cases, so take care to
+        # use rec.recarray.field to avoid a potential infinite
+        # recursion
+        field = _get_recarray_field(base, name)
+
+        if name not in self._converted:
+            recformat = format.recformat
+            # TODO: If we're now passing the column to these subroutines, do we
+            # really need to pass them the recformat?
+            if isinstance(recformat, _FormatP):
+                # for P format
+                converted = self._convert_p(column, field, recformat)
+            else:
+                # Handle all other column data types which are fixed-width
+                # fields
+                converted = self._convert_other(column, field, recformat)
+
+            # Note: Never assign values directly into the self._converted dict;
+            # always go through self._cache_field; this way self._converted is
+            # only used to store arrays that are not already direct views of
+            # our own data.
+            self._cache_field(name, converted)
+            return converted
+
+        return self._converted[name]
+
+    def _cache_field(self, name, field):
+        """
+        Do not store fields in _converted if one of its bases is self,
+        or if it has a common base with self.
+
+        This results in a reference cycle that cannot be broken since
+        ndarrays do not participate in cyclic garbage collection.
+        """
+
+        base = field
+        while True:
+            self_base = self
+            while True:
+                if self_base is base:
+                    return
+
+                if getattr(self_base, 'base', None) is not None:
+                    self_base = self_base.base
+                else:
+                    break
+
+            if getattr(base, 'base', None) is not None:
+                base = base.base
+            else:
+                break
+
+        self._converted[name] = field
+
+    def _update_column_attribute_changed(self, column, idx, attr, old_value,
+                                         new_value):
+        """
+        Update how the data is formatted depending on changes to column
+        attributes initiated by the user through the `Column` interface.
+
+        Dispatches column attribute change notifications to individual methods
+        for each attribute ``_update_column_<attr>``
+        """
+
+        method_name = '_update_column_{0}'.format(attr)
+        if hasattr(self, method_name):
+            # Right now this is so we can be lazy and not implement updaters
+            # for every attribute yet--some we may not need at all, TBD
+            getattr(self, method_name)(column, idx, old_value, new_value)
+
+    def _update_column_name(self, column, idx, old_name, name):
+        """Update the dtype field names when a column name is changed."""
+
+        dtype = self.dtype
+        # Updating the names on the dtype should suffice
+        dtype.names = dtype.names[:idx] + (name,) + dtype.names[idx + 1:]
+
+    def _convert_x(self, field, recformat):
+        """Convert a raw table column to a bit array as specified by the
+        FITS X format.
+        """
+
+        dummy = np.zeros(self.shape + (recformat.repeat,), dtype=np.bool_)
+        _unwrapx(field, dummy, recformat.repeat)
+        return dummy
+
+    def _convert_p(self, column, field, recformat):
+        """Convert a raw table column of FITS P or Q format descriptors
+        to a VLA column with the array data returned from the heap.
+        """
+
+        dummy = _VLF([None] * len(self), dtype=recformat.dtype)
+        raw_data = self._get_raw_data()
+
+        if raw_data is None:
+            raise OSError(
+                "Could not find heap data for the {!r} variable-length "
+                "array column.".format(column.name))
+
+        for idx in range(len(self)):
+            offset = field[idx, 1] + self._heapoffset
+            count = field[idx, 0]
+
+            if recformat.dtype == 'a':
+                dt = np.dtype(recformat.dtype + str(1))
+                arr_len = count * dt.itemsize
+                da = raw_data[offset:offset + arr_len].view(dt)
+                da = np.char.array(da.view(dtype=dt), itemsize=count)
+                dummy[idx] = decode_ascii(da)
+            else:
+                dt = np.dtype(recformat.dtype)
+                arr_len = count * dt.itemsize
+                dummy[idx] = raw_data[offset:offset + arr_len].view(dt)
+                dummy[idx].dtype = dummy[idx].dtype.newbyteorder('>')
+                # Each array in the field may now require additional
+                # scaling depending on the other scaling parameters
+                # TODO: The same scaling parameters apply to every
+                # array in the column so this is currently very slow; we
+                # really only need to check once whether any scaling will
+                # be necessary and skip this step if not
+                # TODO: Test that this works for X format; I don't think
+                # that it does--the recformat variable only applies to the P
+                # format not the X format
+                dummy[idx] = self._convert_other(column, dummy[idx],
+                                                 recformat)
+
+        return dummy
+
+    def _convert_ascii(self, column, field):
+        """
+        Special handling for ASCII table columns to convert columns containing
+        numeric types to actual numeric arrays from the string representation.
+        """
+
+        format = column.format
+        recformat = ASCII2NUMPY[format[0]]
+        # if the string = TNULL, return ASCIITNULL
+        nullval = str(column.null).strip().encode('ascii')
+        if len(nullval) > format.width:
+            nullval = nullval[:format.width]
+
+        # Before using .replace make sure that any trailing bytes in each
+        # column are filled with spaces, and *not*, say, nulls; this causes
+        # functions like replace to potentially leave gibberish bytes in the
+        # array buffer.
+        dummy = np.char.ljust(field, format.width)
+        dummy = np.char.replace(dummy, encode_ascii('D'), encode_ascii('E'))
+        null_fill = encode_ascii(str(ASCIITNULL).rjust(format.width))
+
+        # Convert all fields equal to the TNULL value (nullval) to empty fields.
+        # TODO: These fields really should be conerted to NaN or something else undefined.
+        # Currently they are converted to empty fields, which are then set to zero.
+        dummy = np.where(np.char.strip(dummy) == nullval, null_fill, dummy)
+
+        # always replace empty fields, see https://github.com/astropy/astropy/pull/5394
+        if nullval != b'':
+            dummy = np.where(np.char.strip(dummy) == b'', null_fill, dummy)
+
+        try:
+            dummy = np.array(dummy, dtype=recformat)
+        except ValueError as exc:
+            indx = self.names.index(column.name)
+            raise ValueError(
+                '{}; the header may be missing the necessary TNULL{} '
+                'keyword or the table contains invalid data'.format(
+                    exc, indx + 1))
+
+        return dummy
+
+    def _convert_other(self, column, field, recformat):
+        """Perform conversions on any other fixed-width column data types.
+
+        This may not perform any conversion at all if it's not necessary, in
+        which case the original column array is returned.
+        """
+
+        if isinstance(recformat, _FormatX):
+            # special handling for the X format
+            return self._convert_x(field, recformat)
+
+        (_str, _bool, _number, _scale, _zero, bscale, bzero, dim) = \
+            self._get_scale_factors(column)
+
+        indx = self.names.index(column.name)
+
+        # ASCII table, convert strings to numbers
+        # TODO:
+        # For now, check that these are ASCII columns by checking the coldefs
+        # type; in the future all columns (for binary tables, ASCII tables, or
+        # otherwise) should "know" what type they are already and how to handle
+        # converting their data from FITS format to native format and vice
+        # versa...
+        if not _str and isinstance(self._coldefs, _AsciiColDefs):
+            field = self._convert_ascii(column, field)
+
+        # Test that the dimensions given in dim are sensible; otherwise
+        # display a warning and ignore them
+        if dim:
+            # See if the dimensions already match, if not, make sure the
+            # number items will fit in the specified dimensions
+            if field.ndim > 1:
+                actual_shape = field.shape[1:]
+                if _str:
+                    actual_shape = actual_shape + (field.itemsize,)
+            else:
+                actual_shape = field.shape[0]
+
+            if dim == actual_shape:
+                # The array already has the correct dimensions, so we
+                # ignore dim and don't convert
+                dim = None
+            else:
+                nitems = reduce(operator.mul, dim)
+                if _str:
+                    actual_nitems = field.itemsize
+                elif len(field.shape) == 1:  # No repeat count in TFORMn, equivalent to 1
+                    actual_nitems = 1
+                else:
+                    actual_nitems = field.shape[1]
+                if nitems > actual_nitems:
+                    warnings.warn(
+                        'TDIM{} value {:d} does not fit with the size of '
+                        'the array items ({:d}).  TDIM{:d} will be ignored.'
+                        .format(indx + 1, self._coldefs[indx].dims,
+                                actual_nitems, indx + 1))
+                    dim = None
+
+        # further conversion for both ASCII and binary tables
+        # For now we've made columns responsible for *knowing* whether their
+        # data has been scaled, but we make the FITS_rec class responsible for
+        # actually doing the scaling
+        # TODO: This also needs to be fixed in the effort to make Columns
+        # responsible for scaling their arrays to/from FITS native values
+        if not column.ascii and column.format.p_format:
+            format_code = column.format.p_format
+        else:
+            # TODO: Rather than having this if/else it might be nice if the
+            # ColumnFormat class had an attribute guaranteed to give the format
+            # of actual values in a column regardless of whether the true
+            # format is something like P or Q
+            format_code = column.format.format
+
+        if (_number and (_scale or _zero) and not column._physical_values):
+            # This is to handle pseudo unsigned ints in table columns
+            # TODO: For now this only really works correctly for binary tables
+            # Should it work for ASCII tables as well?
+            if self._uint:
+                if bzero == 2**15 and format_code == 'I':
+                    field = np.array(field, dtype=np.uint16)
+                elif bzero == 2**31 and format_code == 'J':
+                    field = np.array(field, dtype=np.uint32)
+                elif bzero == 2**63 and format_code == 'K':
+                    field = np.array(field, dtype=np.uint64)
+                    bzero64 = np.uint64(2 ** 63)
+                else:
+                    field = np.array(field, dtype=np.float64)
+            else:
+                field = np.array(field, dtype=np.float64)
+
+            if _scale:
+                np.multiply(field, bscale, field)
+            if _zero:
+                if self._uint and format_code == 'K':
+                    # There is a chance of overflow, so be careful
+                    test_overflow = field.copy()
+                    try:
+                        test_overflow += bzero64
+                    except OverflowError:
+                        warnings.warn(
+                            "Overflow detected while applying TZERO{0:d}. "
+                            "Returning unscaled data.".format(indx + 1))
+                    else:
+                        field = test_overflow
+                else:
+                    field += bzero
+
+            # mark the column as scaled
+            column._physical_values = True
+
+        elif _bool and field.dtype != bool:
+            field = np.equal(field, ord('T'))
+        elif _str:
+            if not self._character_as_bytes:
+                with suppress(UnicodeDecodeError):
+                    field = decode_ascii(field)
+
+        if dim:
+            # Apply the new field item dimensions
+            nitems = reduce(operator.mul, dim)
+            if field.ndim > 1:
+                field = field[:, :nitems]
+            if _str:
+                fmt = field.dtype.char
+                dtype = ('|{}{}'.format(fmt, dim[-1]), dim[:-1])
+                field.dtype = dtype
+            else:
+                field.shape = (field.shape[0],) + dim
+
+        return field
+
+    def _get_heap_data(self):
+        """
+        Returns a pointer into the table's raw data to its heap (if present).
+
+        This is returned as a numpy byte array.
+        """
+
+        if self._heapsize:
+            raw_data = self._get_raw_data().view(np.ubyte)
+            heap_end = self._heapoffset + self._heapsize
+            return raw_data[self._heapoffset:heap_end]
+        else:
+            return np.array([], dtype=np.ubyte)
+
+    def _get_raw_data(self):
+        """
+        Returns the base array of self that "raw data array" that is the
+        array in the format that it was first read from a file before it was
+        sliced or viewed as a different type in any way.
+
+        This is determined by walking through the bases until finding one that
+        has at least the same number of bytes as self, plus the heapsize.  This
+        may be the immediate .base but is not always.  This is used primarily
+        for variable-length array support which needs to be able to find the
+        heap (the raw data *may* be larger than nbytes + heapsize if it
+        contains a gap or padding).
+
+        May return ``None`` if no array resembling the "raw data" according to
+        the stated criteria can be found.
+        """
+
+        raw_data_bytes = self.nbytes + self._heapsize
+        base = self
+        while hasattr(base, 'base') and base.base is not None:
+            base = base.base
+            if hasattr(base, 'nbytes') and base.nbytes >= raw_data_bytes:
+                return base
+
+    def _get_scale_factors(self, column):
+        """Get all the scaling flags and factors for one column."""
+
+        # TODO: Maybe this should be a method/property on Column?  Or maybe
+        # it's not really needed at all...
+        _str = column.format.format == 'A'
+        _bool = column.format.format == 'L'
+
+        _number = not (_bool or _str)
+        bscale = column.bscale
+        bzero = column.bzero
+
+        _scale = bscale not in ('', None, 1)
+        _zero = bzero not in ('', None, 0)
+
+        # ensure bscale/bzero are numbers
+        if not _scale:
+            bscale = 1
+        if not _zero:
+            bzero = 0
+
+        # column._dims gives a tuple, rather than column.dim which returns the
+        # original string format code from the FITS header...
+        dim = column._dims
+
+        return (_str, _bool, _number, _scale, _zero, bscale, bzero, dim)
+
+    def _scale_back(self, update_heap_pointers=True):
+        """
+        Update the parent array, using the (latest) scaled array.
+
+        If ``update_heap_pointers`` is `False`, this will leave all the heap
+        pointers in P/Q columns as they are verbatim--it only makes sense to do
+        this if there is already data on the heap and it can be guaranteed that
+        that data has not been modified, and there is not new data to add to
+        the heap.  Currently this is only used as an optimization for
+        CompImageHDU that does its own handling of the heap.
+        """
+
+        # Running total for the new heap size
+        heapsize = 0
+
+        for indx, name in enumerate(self.dtype.names):
+            column = self._coldefs[indx]
+            recformat = column.format.recformat
+            raw_field = _get_recarray_field(self, indx)
+
+            # add the location offset of the heap area for each
+            # variable length column
+            if isinstance(recformat, _FormatP):
+                # Irritatingly, this can return a different dtype than just
+                # doing np.dtype(recformat.dtype); but this returns the results
+                # that we want.  For example if recformat.dtype is 'a' we want
+                # an array of characters.
+                dtype = np.array([], dtype=recformat.dtype).dtype
+
+                if update_heap_pointers and name in self._converted:
+                    # The VLA has potentially been updated, so we need to
+                    # update the array descriptors
+                    raw_field[:] = 0  # reset
+                    npts = [len(arr) for arr in self._converted[name]]
+
+                    raw_field[:len(npts), 0] = npts
+                    raw_field[1:, 1] = (np.add.accumulate(raw_field[:-1, 0]) *
+                                        dtype.itemsize)
+                    raw_field[:, 1][:] += heapsize
+
+                heapsize += raw_field[:, 0].sum() * dtype.itemsize
+                # Even if this VLA has not been read or updated, we need to
+                # include the size of its constituent arrays in the heap size
+                # total
+
+            if isinstance(recformat, _FormatX) and name in self._converted:
+                _wrapx(self._converted[name], raw_field, recformat.repeat)
+                continue
+
+            _str, _bool, _number, _scale, _zero, bscale, bzero, _ = \
+                self._get_scale_factors(column)
+
+            field = self._converted.get(name, raw_field)
+
+            # conversion for both ASCII and binary tables
+            if _number or _str:
+                if _number and (_scale or _zero) and column._physical_values:
+                    dummy = field.copy()
+                    if _zero:
+                        dummy -= bzero
+                    if _scale:
+                        dummy /= bscale
+                    # This will set the raw values in the recarray back to
+                    # their non-physical storage values, so the column should
+                    # be mark is not scaled
+                    column._physical_values = False
+                elif _str or isinstance(self._coldefs, _AsciiColDefs):
+                    dummy = field
+                else:
+                    continue
+
+                # ASCII table, convert numbers to strings
+                if isinstance(self._coldefs, _AsciiColDefs):
+                    self._scale_back_ascii(indx, dummy, raw_field)
+                # binary table string column
+                elif isinstance(raw_field, chararray.chararray):
+                    self._scale_back_strings(indx, dummy, raw_field)
+                # all other binary table columns
+                else:
+                    if len(raw_field) and isinstance(raw_field[0],
+                                                     np.integer):
+                        dummy = np.around(dummy)
+
+                    if raw_field.shape == dummy.shape:
+                        raw_field[:] = dummy
+                    else:
+                        # Reshaping the data is necessary in cases where the
+                        # TDIMn keyword was used to shape a column's entries
+                        # into arrays
+                        raw_field[:] = dummy.ravel().view(raw_field.dtype)
+
+                del dummy
+
+            # ASCII table does not have Boolean type
+            elif _bool and name in self._converted:
+                choices = (np.array([ord('F')], dtype=np.int8)[0],
+                           np.array([ord('T')], dtype=np.int8)[0])
+                raw_field[:] = np.choose(field, choices)
+
+        # Store the updated heapsize
+        self._heapsize = heapsize
+
+    def _scale_back_strings(self, col_idx, input_field, output_field):
+        # There are a few possibilities this has to be able to handle properly
+        # The input_field, which comes from the _converted column is of dtype
+        # 'Un' so that elements read out of the array are normal str
+        # objects (i.e. unicode strings)
+        #
+        # At the other end the *output_field* may also be of type 'S' or of
+        # type 'U'.  It will *usually* be of type 'S' because when reading
+        # an existing FITS table the raw data is just ASCII strings, and
+        # represented in Numpy as an S array.  However, when a user creates
+        # a new table from scratch, they *might* pass in a column containing
+        # unicode strings (dtype 'U').  Therefore the output_field of the
+        # raw array is actually a unicode array.  But we still want to make
+        # sure the data is encodable as ASCII.  Later when we write out the
+        # array we use, in the dtype 'U' case, a different write routine
+        # that writes row by row and encodes any 'U' columns to ASCII.
+
+        # If the output_field is non-ASCII we will worry about ASCII encoding
+        # later when writing; otherwise we can do it right here
+        if input_field.dtype.kind == 'U' and output_field.dtype.kind == 'S':
+            try:
+                _ascii_encode(input_field, out=output_field)
+            except _UnicodeArrayEncodeError as exc:
+                raise ValueError(
+                    "Could not save column '{0}': Contains characters that "
+                    "cannot be encoded as ASCII as required by FITS, starting "
+                    "at the index {1!r} of the column, and the index {2} of "
+                    "the string at that location.".format(
+                        self._coldefs[col_idx].name,
+                        exc.index[0] if len(exc.index) == 1 else exc.index,
+                        exc.start))
+        else:
+            # Otherwise go ahead and do a direct copy into--if both are type
+            # 'U' we'll handle encoding later
+            input_field = input_field.flatten().view(output_field.dtype)
+            output_field.flat[:] = input_field
+
+        # Ensure that blanks at the end of each string are
+        # converted to nulls instead of spaces, see Trac #15
+        # and #111
+        _rstrip_inplace(output_field)
+
+    def _scale_back_ascii(self, col_idx, input_field, output_field):
+        """
+        Convert internal array values back to ASCII table representation.
+
+        The ``input_field`` is the internal representation of the values, and
+        the ``output_field`` is the character array representing the ASCII
+        output that will be written.
+        """
+
+        starts = self._coldefs.starts[:]
+        spans = self._coldefs.spans
+        format = self._coldefs[col_idx].format
+
+        # The the index of the "end" column of the record, beyond
+        # which we can't write
+        end = super().field(-1).itemsize
+        starts.append(end + starts[-1])
+
+        if col_idx > 0:
+            lead = starts[col_idx] - starts[col_idx - 1] - spans[col_idx - 1]
+        else:
+            lead = 0
+
+        if lead < 0:
+            warnings.warn('Column {!r} starting point overlaps the previous '
+                          'column.'.format(col_idx + 1))
+
+        trail = starts[col_idx + 1] - starts[col_idx] - spans[col_idx]
+
+        if trail < 0:
+            warnings.warn('Column {!r} ending point overlaps the next '
+                          'column.'.format(col_idx + 1))
+
+        # TODO: It would be nice if these string column formatting
+        # details were left to a specialized class, as is the case
+        # with FormatX and FormatP
+        if 'A' in format:
+            _pc = '{:'
+        else:
+            _pc = '{:>'
+
+        fmt = ''.join([_pc, format[1:], ASCII2STR[format[0]], '}',
+                       (' ' * trail)])
+
+        # Even if the format precision is 0, we should output a decimal point
+        # as long as there is space to do so--not including a decimal point in
+        # a float value is discouraged by the FITS Standard
+        trailing_decimal = (format.precision == 0 and
+                            format.format in ('F', 'E', 'D'))
+
+        # not using numarray.strings's num2char because the
+        # result is not allowed to expand (as C/Python does).
+        for jdx, value in enumerate(input_field):
+            value = fmt.format(value)
+            if len(value) > starts[col_idx + 1] - starts[col_idx]:
+                raise ValueError(
+                    "Value {!r} does not fit into the output's itemsize of "
+                    "{}.".format(value, spans[col_idx]))
+
+            if trailing_decimal and value[0] == ' ':
+                # We have some extra space in the field for the trailing
+                # decimal point
+                value = value[1:] + '.'
+
+            output_field[jdx] = value
+
+        # Replace exponent separator in floating point numbers
+        if 'D' in format:
+            output_field[:] = output_field.replace(b'E', b'D')
+
+
+def _get_recarray_field(array, key):
+    """
+    Compatibility function for using the recarray base class's field method.
+    This incorporates the legacy functionality of returning string arrays as
+    Numeric-style chararray objects.
+    """
+
+    # Numpy >= 1.10.dev recarray no longer returns chararrays for strings
+    # This is currently needed for backwards-compatibility and for
+    # automatic truncation of trailing whitespace
+    field = np.recarray.field(array, key)
+    if (field.dtype.char in ('S', 'U') and
+            not isinstance(field, chararray.chararray)):
+        field = field.view(chararray.chararray)
+    return field
+
+
+class _UnicodeArrayEncodeError(UnicodeEncodeError):
+    def __init__(self, encoding, object_, start, end, reason, index):
+        super().__init__(encoding, object_, start, end, reason)
+        self.index = index
+
+
+def _ascii_encode(inarray, out=None):
+    """
+    Takes a unicode array and fills the output string array with the ASCII
+    encodings (if possible) of the elements of the input array.  The two arrays
+    must be the same size (though not necessarily the same shape).
+
+    This is like an inplace version of `np.char.encode` though simpler since
+    it's only limited to ASCII, and hence the size of each character is
+    guaranteed to be 1 byte.
+
+    If any strings are non-ASCII an UnicodeArrayEncodeError is raised--this is
+    just a `UnicodeEncodeError` with an additional attribute for the index of
+    the item that couldn't be encoded.
+    """
+
+    out_dtype = np.dtype(('S{0}'.format(inarray.dtype.itemsize // 4),
+                         inarray.dtype.shape))
+    if out is not None:
+        out = out.view(out_dtype)
+
+    op_dtypes = [inarray.dtype, out_dtype]
+    op_flags = [['readonly'], ['writeonly', 'allocate']]
+    it = np.nditer([inarray, out], op_dtypes=op_dtypes,
+                   op_flags=op_flags, flags=['zerosize_ok'])
+
+    try:
+        for initem, outitem in it:
+            outitem[...] = initem.item().encode('ascii')
+    except UnicodeEncodeError as exc:
+        index = np.unravel_index(it.iterindex, inarray.shape)
+        raise _UnicodeArrayEncodeError(*(exc.args + (index,)))
+
+    return it.operands[1]
+
+
+def _has_unicode_fields(array):
+    """
+    Returns True if any fields in a structured array have Unicode dtype.
+    """
+
+    dtypes = (d[0] for d in array.dtype.fields.values())
+    return any(d.kind == 'U' for d in dtypes)

testbed/astropy__astropy/astropy/io/fits/fitstime.py

@@ -0,0 +1,576 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+import re
+import warnings
+from collections import defaultdict, OrderedDict
+
+import numpy as np
+
+from . import Header, Card
+
+from astropy import units as u
+from astropy.coordinates import EarthLocation
+from astropy.table import Column
+from astropy.time import Time, TimeDelta
+from astropy.time.core import BARYCENTRIC_SCALES
+from astropy.time.formats import FITS_DEPRECATED_SCALES
+from astropy.utils.exceptions import AstropyUserWarning
+
+# The following is based on the FITS WCS Paper IV, "Representations of time
+# coordinates in FITS".
+# http://adsabs.harvard.edu/abs/2015A%26A...574A..36R
+
+
+# FITS WCS standard specified "4-3" form for non-linear coordinate types
+TCTYP_RE_TYPE = re.compile(r'(?P<type>[A-Z]+)[-]+')
+TCTYP_RE_ALGO = re.compile(r'(?P<algo>[A-Z]+)\s*')
+
+
+# FITS Time standard specified time units
+FITS_TIME_UNIT = ['s', 'd', 'a', 'cy', 'min', 'h', 'yr', 'ta', 'Ba']
+
+
+# Global time reference coordinate keywords
+TIME_KEYWORDS = ('TIMESYS', 'MJDREF', 'JDREF', 'DATEREF',
+                 'TREFPOS', 'TREFDIR', 'TIMEUNIT', 'TIMEOFFS',
+                 'OBSGEO-X', 'OBSGEO-Y', 'OBSGEO-Z',
+                 'OBSGEO-L', 'OBSGEO-B', 'OBSGEO-H', 'DATE',
+                 'DATE-OBS', 'DATE-AVG', 'DATE-BEG', 'DATE-END',
+                 'MJD-OBS', 'MJD-AVG', 'MJD-BEG', 'MJD-END')
+
+
+# Column-specific time override keywords
+COLUMN_TIME_KEYWORDS = ('TCTYP', 'TCUNI', 'TRPOS')
+
+
+# Column-specific keywords regex
+COLUMN_TIME_KEYWORD_REGEXP = '({0})[0-9]+'.format(
+    '|'.join(COLUMN_TIME_KEYWORDS))
+
+
+def is_time_column_keyword(keyword):
+    """
+    Check if the FITS header keyword is a time column-specific keyword.
+
+    Parameters
+    ----------
+    keyword : str
+        FITS keyword.
+    """
+    return re.match(COLUMN_TIME_KEYWORD_REGEXP, keyword) is not None
+
+
+# Set astropy time global information
+GLOBAL_TIME_INFO = {'TIMESYS': ('UTC', 'Default time scale'),
+                    'JDREF': (0.0, 'Time columns are jd = jd1 + jd2'),
+                    'TREFPOS': ('TOPOCENTER', 'Time reference position')}
+
+
+def _verify_global_info(global_info):
+    """
+    Given the global time reference frame information, verify that
+    each global time coordinate attribute will be given a valid value.
+
+    Parameters
+    ----------
+    global_info : dict
+        Global time reference frame information.
+    """
+
+    # Translate FITS deprecated scale into astropy scale, or else just convert
+    # to lower case for further checks.
+    global_info['scale'] = FITS_DEPRECATED_SCALES.get(global_info['TIMESYS'],
+                                                      global_info['TIMESYS'].lower())
+
+    # Verify global time scale
+    if global_info['scale'] not in Time.SCALES:
+
+        # 'GPS' and 'LOCAL' are FITS recognized time scale values
+        # but are not supported by astropy.
+
+        if global_info['scale'] == 'gps':
+            warnings.warn(
+                'Global time scale (TIMESYS) has a FITS recognized time scale '
+                'value "GPS". In Astropy, "GPS" is a time from epoch format '
+                'which runs synchronously with TAI; GPS is approximately 19 s '
+                'ahead of TAI. Hence, this format will be used.', AstropyUserWarning)
+            # Assume that the values are in GPS format
+            global_info['scale'] = 'tai'
+            global_info['format'] = 'gps'
+
+        if global_info['scale'] == 'local':
+            warnings.warn(
+                'Global time scale (TIMESYS) has a FITS recognized time scale '
+                'value "LOCAL". However, the standard states that "LOCAL" should be '
+                'tied to one of the existing scales because it is intrinsically '
+                'unreliable and/or ill-defined. Astropy will thus use the default '
+                'global time scale "UTC" instead of "LOCAL".', AstropyUserWarning)
+            # Default scale 'UTC'
+            global_info['scale'] = 'utc'
+            global_info['format'] = None
+
+        else:
+            raise AssertionError(
+                'Global time scale (TIMESYS) should have a FITS recognized '
+                'time scale value (got {!r}). The FITS standard states that '
+                'the use of local time scales should be restricted to alternate '
+                'coordinates.'.format(global_info['TIMESYS']))
+    else:
+        # Scale is already set
+        global_info['format'] = None
+
+    # Check if geocentric global location is specified
+    obs_geo = [global_info[attr] for attr in ('OBSGEO-X', 'OBSGEO-Y', 'OBSGEO-Z')
+               if attr in global_info]
+
+    # Location full specification is (X, Y, Z)
+    if len(obs_geo) == 3:
+        global_info['location'] = EarthLocation.from_geocentric(*obs_geo, unit=u.m)
+    else:
+        # Check if geodetic global location is specified (since geocentric failed)
+
+        # First warn the user if geocentric location is partially specified
+        if obs_geo:
+            warnings.warn(
+                'The geocentric observatory location {} is not completely '
+                'specified (X, Y, Z) and will be ignored.'.format(obs_geo),
+                AstropyUserWarning)
+
+        # Check geodetic location
+        obs_geo = [global_info[attr] for attr in ('OBSGEO-L', 'OBSGEO-B', 'OBSGEO-H')
+                   if attr in global_info]
+
+        if len(obs_geo) == 3:
+            global_info['location'] = EarthLocation.from_geodetic(*obs_geo)
+        else:
+            # Since both geocentric and geodetic locations are not specified,
+            # location will be None.
+
+            # Warn the user if geodetic location is partially specified
+            if obs_geo:
+                warnings.warn(
+                    'The geodetic observatory location {} is not completely '
+                    'specified (lon, lat, alt) and will be ignored.'.format(obs_geo),
+                    AstropyUserWarning)
+            global_info['location'] = None
+
+    # Get global time reference
+    # Keywords are listed in order of precedence, as stated by the standard
+    for key, format_ in (('MJDREF', 'mjd'), ('JDREF', 'jd'), ('DATEREF', 'fits')):
+        if key in global_info:
+            global_info['ref_time'] = {'val': global_info[key], 'format': format_}
+            break
+    else:
+        # If none of the three keywords is present, MJDREF = 0.0 must be assumed
+        global_info['ref_time'] = {'val': 0, 'format': 'mjd'}
+
+
+def _verify_column_info(column_info, global_info):
+    """
+    Given the column-specific time reference frame information, verify that
+    each column-specific time coordinate attribute has a valid value.
+    Return True if the coordinate column is time, or else return False.
+
+    Parameters
+    ----------
+    global_info : dict
+        Global time reference frame information.
+    column_info : dict
+        Column-specific time reference frame override information.
+    """
+
+    scale = column_info.get('TCTYP', None)
+    unit = column_info.get('TCUNI', None)
+    location = column_info.get('TRPOS', None)
+
+    if scale is not None:
+
+        # Non-linear coordinate types have "4-3" form and are not time coordinates
+        if TCTYP_RE_TYPE.match(scale[:5]) and TCTYP_RE_ALGO.match(scale[5:]):
+            return False
+
+        elif scale.lower() in Time.SCALES:
+            column_info['scale'] = scale.lower()
+            column_info['format'] = None
+
+        elif scale in FITS_DEPRECATED_SCALES.keys():
+            column_info['scale'] = FITS_DEPRECATED_SCALES[scale]
+            column_info['format'] = None
+
+        # TCTYPn (scale) = 'TIME' indicates that the column scale is
+        # controlled by the global scale.
+        elif scale == 'TIME':
+            column_info['scale'] = global_info['scale']
+            column_info['format'] = global_info['format']
+
+        elif scale == 'GPS':
+            warnings.warn(
+                'Table column "{}" has a FITS recognized time scale value "GPS". '
+                'In Astropy, "GPS" is a time from epoch format which runs '
+                'synchronously with TAI; GPS runs ahead of TAI approximately '
+                'by 19 s. Hence, this format will be used.'.format(column_info),
+                AstropyUserWarning)
+            column_info['scale'] = 'tai'
+            column_info['format'] = 'gps'
+
+        elif scale == 'LOCAL':
+            warnings.warn(
+                'Table column "{}" has a FITS recognized time scale value "LOCAL". '
+                'However, the standard states that "LOCAL" should be tied to one '
+                'of the existing scales because it is intrinsically unreliable '
+                'and/or ill-defined. Astropy will thus use the global time scale '
+                '(TIMESYS) as the default.'. format(column_info),
+                AstropyUserWarning)
+            column_info['scale'] = global_info['scale']
+            column_info['format'] = global_info['format']
+
+        else:
+            # Coordinate type is either an unrecognized local time scale
+            # or a linear coordinate type
+            return False
+
+    # If TCUNIn is a time unit or TRPOSn is specified, the column is a time
+    # coordinate. This has to be tested since TCTYP (scale) is not specified.
+    elif (unit is not None and unit in FITS_TIME_UNIT) or location is not None:
+        column_info['scale'] = global_info['scale']
+        column_info['format'] = global_info['format']
+
+    # None of the conditions for time coordinate columns is satisfied
+    else:
+        return False
+
+    # Check if column-specific reference position TRPOSn is specified
+    if location is not None:
+
+        # Observatory position (location) needs to be specified only
+        # for 'TOPOCENTER'.
+        if location == 'TOPOCENTER':
+            column_info['location'] = global_info['location']
+            if column_info['location'] is None:
+                warnings.warn(
+                    'Time column reference position "TRPOSn" value is "TOPOCENTER". '
+                    'However, the observatory position is not properly specified. '
+                    'The FITS standard does not support this and hence reference '
+                    'position will be ignored.', AstropyUserWarning)
+        else:
+            column_info['location'] = None
+
+    # Since TRPOSn is not specified, global reference position is
+    # considered.
+    elif global_info['TREFPOS'] == 'TOPOCENTER':
+
+        column_info['location'] = global_info['location']
+        if column_info['location'] is None:
+            warnings.warn(
+                'Time column reference position "TRPOSn" is not specified. The '
+                'default value for it is "TOPOCENTER", but due to unspecified '
+                'observatory position, reference position will be ignored.',
+                AstropyUserWarning)
+    else:
+        column_info['location'] = None
+
+    # Get reference time
+    column_info['ref_time'] = global_info['ref_time']
+
+    return True
+
+
+def _get_info_if_time_column(col, global_info):
+    """
+    Check if a column without corresponding time column keywords in the
+    FITS header represents time or not. If yes, return the time column
+    information needed for its conversion to Time.
+    This is only applicable to the special-case where a column has the
+    name 'TIME' and a time unit.
+    """
+
+    # Column with TTYPEn = 'TIME' and lacking any TC*n or time
+    # specific keywords will be controlled by the global keywords.
+    if col.info.name.upper() == 'TIME' and col.info.unit in FITS_TIME_UNIT:
+        column_info = {'scale': global_info['scale'],
+                       'format': global_info['format'],
+                       'ref_time': global_info['ref_time'],
+                       'location': None}
+
+        if global_info['TREFPOS'] == 'TOPOCENTER':
+            column_info['location'] = global_info['location']
+            if column_info['location'] is None:
+                warnings.warn(
+                    'Time column "{}" reference position will be ignored '
+                    'due to unspecified observatory position.'.format(col.info.name),
+                    AstropyUserWarning)
+
+        return column_info
+
+    return None
+
+
+def _convert_global_time(table, global_info):
+    """
+    Convert the table metadata for time informational keywords
+    to astropy Time.
+
+    Parameters
+    ----------
+    table : `~astropy.table.Table`
+        The table whose time metadata is to be converted.
+    global_info : dict
+        Global time reference frame information.
+    """
+
+    # Read in Global Informational keywords as Time
+    for key, value in global_info.items():
+        # FITS uses a subset of ISO-8601 for DATE-xxx
+        if key.startswith('DATE'):
+            if key not in table.meta:
+                scale = 'utc' if key == 'DATE' else global_info['scale']
+                try:
+                    precision = len(value.split('.')[-1]) if '.' in value else 0
+                    value = Time(value, format='fits', scale=scale,
+                                 precision=precision)
+                except ValueError:
+                    pass
+                table.meta[key] = value
+
+        # MJD-xxx in MJD according to TIMESYS
+        elif key.startswith('MJD-'):
+            if key not in table.meta:
+                try:
+                    value = Time(value, format='mjd',
+                                 scale=global_info['scale'])
+                except ValueError:
+                    pass
+                table.meta[key] = value
+
+
+def _convert_time_column(col, column_info):
+    """
+    Convert time columns to astropy Time columns.
+
+    Parameters
+    ----------
+    col : `~astropy.table.Column`
+        The time coordinate column to be converted to Time.
+    column_info : dict
+        Column-specific time reference frame override information.
+    """
+
+    # The code might fail while attempting to read FITS files not written by astropy.
+    try:
+        # ISO-8601 is the only string representation of time in FITS
+        if col.info.dtype.kind in ['S', 'U']:
+            # [+/-C]CCYY-MM-DD[Thh:mm:ss[.s...]] where the number of characters
+            # from index 20 to the end of string represents the precision
+            precision = max(int(col.info.dtype.str[2:]) - 20, 0)
+            return Time(col, format='fits', scale=column_info['scale'],
+                        precision=precision,
+                        location=column_info['location'])
+
+        if column_info['format'] == 'gps':
+            return Time(col, format='gps', location=column_info['location'])
+
+        # If reference value is 0 for JD or MJD, the column values can be
+        # directly converted to Time, as they are absolute (relative
+        # to a globally accepted zero point).
+        if (column_info['ref_time']['val'] == 0 and
+            column_info['ref_time']['format'] in ['jd', 'mjd']):
+            # (jd1, jd2) where jd = jd1 + jd2
+            if col.shape[-1] == 2 and col.ndim > 1:
+                return Time(col[..., 0], col[..., 1], scale=column_info['scale'],
+                            format=column_info['ref_time']['format'],
+                            location=column_info['location'])
+            else:
+                return Time(col, scale=column_info['scale'],
+                            format=column_info['ref_time']['format'],
+                            location=column_info['location'])
+
+        # Reference time
+        ref_time = Time(column_info['ref_time']['val'], scale=column_info['scale'],
+                        format=column_info['ref_time']['format'],
+                        location=column_info['location'])
+
+        # Elapsed time since reference time
+        if col.shape[-1] == 2 and col.ndim > 1:
+            delta_time = TimeDelta(col[..., 0], col[..., 1])
+        else:
+            delta_time = TimeDelta(col)
+
+        return ref_time + delta_time
+    except Exception as err:
+        warnings.warn(
+            'The exception "{}" was encountered while trying to convert the time '
+            'column "{}" to Astropy Time.'.format(err, col.info.name),
+            AstropyUserWarning)
+        return col
+
+
+def fits_to_time(hdr, table):
+    """
+    Read FITS binary table time columns as `~astropy.time.Time`.
+
+    This method reads the metadata associated with time coordinates, as
+    stored in a FITS binary table header, converts time columns into
+    `~astropy.time.Time` columns and reads global reference times as
+    `~astropy.time.Time` instances.
+
+    Parameters
+    ----------
+    hdr : `~astropy.io.fits.header.Header`
+        FITS Header
+    table : `~astropy.table.Table`
+        The table whose time columns are to be read as Time
+
+    Returns
+    -------
+    hdr : `~astropy.io.fits.header.Header`
+        Modified FITS Header (time metadata removed)
+    """
+
+    # Set defaults for global time scale, reference, etc.
+    global_info = {'TIMESYS': 'UTC',
+                   'TREFPOS': 'TOPOCENTER'}
+
+    # Set default dictionary for time columns
+    time_columns = defaultdict(OrderedDict)
+
+    # Make a "copy" (not just a view) of the input header, since it
+    # may get modified.  the data is still a "view" (for now)
+    hcopy = hdr.copy(strip=True)
+
+    # Scan the header for global and column-specific time keywords
+    for key, value, comment in hdr.cards:
+        if key in TIME_KEYWORDS:
+
+            global_info[key] = value
+            hcopy.remove(key)
+
+        elif is_time_column_keyword(key):
+
+            base, idx = re.match(r'([A-Z]+)([0-9]+)', key).groups()
+            time_columns[int(idx)][base] = value
+            hcopy.remove(key)
+
+        elif (value in ('OBSGEO-X', 'OBSGEO-Y', 'OBSGEO-Z') and
+              re.match('TTYPE[0-9]+', key)):
+
+            global_info[value] = table[value]
+
+    # Verify and get the global time reference frame information
+    _verify_global_info(global_info)
+    _convert_global_time(table, global_info)
+
+    # Columns with column-specific time (coordinate) keywords
+    if time_columns:
+        for idx, column_info in time_columns.items():
+            # Check if the column is time coordinate (not spatial)
+            if _verify_column_info(column_info, global_info):
+                colname = table.colnames[idx - 1]
+                # Convert to Time
+                table[colname] = _convert_time_column(table[colname],
+                                                      column_info)
+
+    # Check for special-cases of time coordinate columns
+    for idx, colname in enumerate(table.colnames):
+        if (idx + 1) not in time_columns:
+            column_info = _get_info_if_time_column(table[colname], global_info)
+            if column_info:
+                table[colname] = _convert_time_column(table[colname], column_info)
+
+    return hcopy
+
+
+def time_to_fits(table):
+    """
+    Replace Time columns in a Table with non-mixin columns containing
+    each element as a vector of two doubles (jd1, jd2) and return a FITS
+    header with appropriate time coordinate keywords.
+    jd = jd1 + jd2 represents time in the Julian Date format with
+    high-precision.
+
+    Parameters
+    ----------
+    table : `~astropy.table.Table`
+        The table whose Time columns are to be replaced.
+
+    Returns
+    -------
+    table : `~astropy.table.Table`
+        The table with replaced Time columns
+    hdr : `~astropy.io.fits.header.Header`
+        Header containing global time reference frame FITS keywords
+    """
+
+    # Shallow copy of the input table
+    newtable = table.copy(copy_data=False)
+
+    # Global time coordinate frame keywords
+    hdr = Header([Card(keyword=key, value=val[0], comment=val[1])
+                  for key, val in GLOBAL_TIME_INFO.items()])
+
+    # Store coordinate column-specific metadata
+    newtable.meta['__coordinate_columns__'] = defaultdict(OrderedDict)
+    coord_meta = newtable.meta['__coordinate_columns__']
+
+    time_cols = table.columns.isinstance(Time)
+
+    # Geocentric location
+    location = None
+
+    for col in time_cols:
+        # By default, Time objects are written in full precision, i.e. we store both
+        # jd1 and jd2 (serialize_method['fits'] = 'jd1_jd2'). Formatted values for
+        # Time can be stored if the user explicitly chooses to do so.
+        if col.info.serialize_method['fits'] == 'formatted_value':
+            newtable.replace_column(col.info.name, Column(col.value))
+            continue
+
+        # The following is necessary to deal with multi-dimensional ``Time`` objects
+        # (i.e. where Time.shape is non-trivial).
+        jd12 = np.array([col.jd1, col.jd2])
+        # Roll the 0th (innermost) axis backwards, until it lies in the last position
+        # (jd12.ndim)
+        jd12 = np.rollaxis(jd12, 0, jd12.ndim)
+        newtable.replace_column(col.info.name, Column(jd12, unit='d'))
+
+        # Get column position(index)
+        n = table.colnames.index(col.info.name) + 1
+
+        # Time column-specific override keywords
+        coord_meta[col.info.name]['coord_type'] = col.scale.upper()
+        coord_meta[col.info.name]['coord_unit'] = 'd'
+
+        # Time column reference position
+        if getattr(col, 'location') is None:
+            if location is not None:
+                warnings.warn(
+                    'Time Column "{}" has no specified location, but global Time '
+                    'Position is present, which will be the default for this column '
+                    'in FITS specification.'.format(col.info.name),
+                    AstropyUserWarning)
+        else:
+            coord_meta[col.info.name]['time_ref_pos'] = 'TOPOCENTER'
+            # Compatibility of Time Scales and Reference Positions
+            if col.scale in BARYCENTRIC_SCALES:
+                warnings.warn(
+                    'Earth Location "TOPOCENTER" for Time Column "{}" is incompatabile '
+                    'with scale "{}".'.format(col.info.name, col.scale.upper()),
+                    AstropyUserWarning)
+
+            if location is None:
+                # Set global geocentric location
+                location = col.location
+                if location.size > 1:
+                    for dim in ('x', 'y', 'z'):
+                        newtable.add_column(Column(getattr(location, dim).to_value(u.m)),
+                                            name='OBSGEO-{}'.format(dim.upper()))
+                else:
+                    hdr.extend([Card(keyword='OBSGEO-{}'.format(dim.upper()),
+                                     value=getattr(location, dim).to_value(u.m))
+                            for dim in ('x', 'y', 'z')])
+            elif location != col.location:
+                raise ValueError('Multiple Time Columns with different geocentric '
+                                 'observatory locations ({}, {}) encountered.'
+                                 'This is not supported by the FITS standard.'
+                                 .format(location, col.location))
+
+    return newtable, hdr

testbed/astropy__astropy/astropy/io/fits/header.py

@@ -0,0 +1,2306 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import collections
+import copy
+import itertools
+import re
+import warnings
+
+from .card import Card, _pad, KEYWORD_LENGTH, UNDEFINED
+from .file import _File
+from .util import (encode_ascii, decode_ascii, fileobj_closed,
+                   fileobj_is_binary, path_like)
+from ._utils import parse_header
+
+from astropy.utils import isiterable
+from astropy.utils.exceptions import AstropyUserWarning
+from astropy.utils.decorators import deprecated_renamed_argument
+
+
+BLOCK_SIZE = 2880  # the FITS block size
+
+# This regular expression can match a *valid* END card which just consists of
+# the string 'END' followed by all spaces, or an *invalid* end card which
+# consists of END, followed by any character that is *not* a valid character
+# for a valid FITS keyword (that is, this is not a keyword like 'ENDER' which
+# starts with 'END' but is not 'END'), followed by any arbitrary bytes.  An
+# invalid end card may also consist of just 'END' with no trailing bytes.
+HEADER_END_RE = re.compile(encode_ascii(
+    r'(?:(?P<valid>END {77}) *)|(?P<invalid>END$|END {0,76}[^A-Z0-9_-])'))
+
+
+# According to the FITS standard the only characters that may appear in a
+# header record are the restricted ASCII chars from 0x20 through 0x7E.
+VALID_HEADER_CHARS = set(map(chr, range(0x20, 0x7F)))
+END_CARD = 'END' + ' ' * 77
+
+
+__doctest_skip__ = ['Header', 'Header.comments', 'Header.fromtextfile',
+                    'Header.totextfile', 'Header.set', 'Header.update']
+
+
+class Header:
+    """
+    FITS header class.  This class exposes both a dict-like interface and a
+    list-like interface to FITS headers.
+
+    The header may be indexed by keyword and, like a dict, the associated value
+    will be returned.  When the header contains cards with duplicate keywords,
+    only the value of the first card with the given keyword will be returned.
+    It is also possible to use a 2-tuple as the index in the form (keyword,
+    n)--this returns the n-th value with that keyword, in the case where there
+    are duplicate keywords.
+
+    For example::
+
+        >>> header['NAXIS']
+        0
+        >>> header[('FOO', 1)]  # Return the value of the second FOO keyword
+        'foo'
+
+    The header may also be indexed by card number::
+
+        >>> header[0]  # Return the value of the first card in the header
+        'T'
+
+    Commentary keywords such as HISTORY and COMMENT are special cases: When
+    indexing the Header object with either 'HISTORY' or 'COMMENT' a list of all
+    the HISTORY/COMMENT values is returned::
+
+        >>> header['HISTORY']
+        This is the first history entry in this header.
+        This is the second history entry in this header.
+        ...
+
+    See the Astropy documentation for more details on working with headers.
+    """
+
+    def __init__(self, cards=[], copy=False):
+        """
+        Construct a `Header` from an iterable and/or text file.
+
+        Parameters
+        ----------
+        cards : A list of `Card` objects, optional
+            The cards to initialize the header with. Also allowed are other
+            `Header` (or `dict`-like) objects.
+
+            .. versionchanged:: 1.2
+                Allowed ``cards`` to be a `dict`-like object.
+
+        copy : bool, optional
+
+            If ``True`` copies the ``cards`` if they were another `Header`
+            instance.
+            Default is ``False``.
+
+            .. versionadded:: 1.3
+        """
+        self.clear()
+
+        if isinstance(cards, Header):
+            if copy:
+                cards = cards.copy()
+            cards = cards.cards
+        elif isinstance(cards, dict):
+            cards = cards.items()
+
+        for card in cards:
+            self.append(card, end=True)
+
+        self._modified = False
+
+    def __len__(self):
+        return len(self._cards)
+
+    def __iter__(self):
+        for card in self._cards:
+            yield card.keyword
+
+    def __contains__(self, keyword):
+        if keyword in self._keyword_indices or keyword in self._rvkc_indices:
+            # For the most common case (single, standard form keyword lookup)
+            # this will work and is an O(1) check.  If it fails that doesn't
+            # guarantee absence, just that we have to perform the full set of
+            # checks in self._cardindex
+            return True
+        try:
+            self._cardindex(keyword)
+        except (KeyError, IndexError):
+            return False
+        return True
+
+    def __getitem__(self, key):
+        if isinstance(key, slice):
+            return Header([copy.copy(c) for c in self._cards[key]])
+        elif self._haswildcard(key):
+            return Header([copy.copy(self._cards[idx])
+                           for idx in self._wildcardmatch(key)])
+        elif (isinstance(key, str) and
+              key.upper() in Card._commentary_keywords):
+            key = key.upper()
+            # Special case for commentary cards
+            return _HeaderCommentaryCards(self, key)
+        if isinstance(key, tuple):
+            keyword = key[0]
+        else:
+            keyword = key
+        card = self._cards[self._cardindex(key)]
+        if card.field_specifier is not None and keyword == card.rawkeyword:
+            # This is RVKC; if only the top-level keyword was specified return
+            # the raw value, not the parsed out float value
+            return card.rawvalue
+
+        value = card.value
+        if value == UNDEFINED:
+            return None
+        return value
+
+    def __setitem__(self, key, value):
+        if self._set_slice(key, value, self):
+            return
+
+        if isinstance(value, tuple):
+            if not (0 < len(value) <= 2):
+                raise ValueError(
+                    'A Header item may be set with either a scalar value, '
+                    'a 1-tuple containing a scalar value, or a 2-tuple '
+                    'containing a scalar value and comment string.')
+            if len(value) == 1:
+                value, comment = value[0], None
+                if value is None:
+                    value = UNDEFINED
+            elif len(value) == 2:
+                value, comment = value
+                if value is None:
+                    value = UNDEFINED
+                if comment is None:
+                    comment = ''
+        else:
+            comment = None
+
+        card = None
+        if isinstance(key, int):
+            card = self._cards[key]
+        elif isinstance(key, tuple):
+            card = self._cards[self._cardindex(key)]
+        if value is None:
+            value = UNDEFINED
+        if card:
+            card.value = value
+            if comment is not None:
+                card.comment = comment
+            if card._modified:
+                self._modified = True
+        else:
+            # If we get an IndexError that should be raised; we don't allow
+            # assignment to non-existing indices
+            self._update((key, value, comment))
+
+    def __delitem__(self, key):
+        if isinstance(key, slice) or self._haswildcard(key):
+            # This is very inefficient but it's not a commonly used feature.
+            # If someone out there complains that they make heavy use of slice
+            # deletions and it's too slow, well, we can worry about it then
+            # [the solution is not too complicated--it would be wait 'til all
+            # the cards are deleted before updating _keyword_indices rather
+            # than updating it once for each card that gets deleted]
+            if isinstance(key, slice):
+                indices = range(*key.indices(len(self)))
+                # If the slice step is backwards we want to reverse it, because
+                # it will be reversed in a few lines...
+                if key.step and key.step < 0:
+                    indices = reversed(indices)
+            else:
+                indices = self._wildcardmatch(key)
+            for idx in reversed(indices):
+                del self[idx]
+            return
+        elif isinstance(key, str):
+            # delete ALL cards with the same keyword name
+            key = Card.normalize_keyword(key)
+            indices = self._keyword_indices
+            if key not in self._keyword_indices:
+                indices = self._rvkc_indices
+
+            if key not in indices:
+                # if keyword is not present raise KeyError.
+                # To delete keyword without caring if they were present,
+                # Header.remove(Keyword) can be used with optional argument ignore_missing as True
+                raise KeyError("Keyword '{}' not found.".format(key))
+
+            for idx in reversed(indices[key]):
+                # Have to copy the indices list since it will be modified below
+                del self[idx]
+            return
+
+        idx = self._cardindex(key)
+        card = self._cards[idx]
+        keyword = card.keyword
+        del self._cards[idx]
+        keyword = Card.normalize_keyword(keyword)
+        indices = self._keyword_indices[keyword]
+        indices.remove(idx)
+        if not indices:
+            del self._keyword_indices[keyword]
+
+        # Also update RVKC indices if necessary :/
+        if card.field_specifier is not None:
+            indices = self._rvkc_indices[card.rawkeyword]
+            indices.remove(idx)
+            if not indices:
+                del self._rvkc_indices[card.rawkeyword]
+
+        # We also need to update all other indices
+        self._updateindices(idx, increment=False)
+        self._modified = True
+
+    def __repr__(self):
+        return self.tostring(sep='\n', endcard=False, padding=False)
+
+    def __str__(self):
+        return self.tostring()
+
+    def __eq__(self, other):
+        """
+        Two Headers are equal only if they have the exact same string
+        representation.
+        """
+
+        return str(self) == str(other)
+
+    def __add__(self, other):
+        temp = self.copy(strip=False)
+        temp.extend(other)
+        return temp
+
+    def __iadd__(self, other):
+        self.extend(other)
+        return self
+
+    def _ipython_key_completions_(self):
+        return self.__iter__()
+
+    @property
+    def cards(self):
+        """
+        The underlying physical cards that make up this Header; it can be
+        looked at, but it should not be modified directly.
+        """
+
+        return _CardAccessor(self)
+
+    @property
+    def comments(self):
+        """
+        View the comments associated with each keyword, if any.
+
+        For example, to see the comment on the NAXIS keyword:
+
+            >>> header.comments['NAXIS']
+            number of data axes
+
+        Comments can also be updated through this interface:
+
+            >>> header.comments['NAXIS'] = 'Number of data axes'
+
+        """
+
+        return _HeaderComments(self)
+
+    @property
+    def _modified(self):
+        """
+        Whether or not the header has been modified; this is a property so that
+        it can also check each card for modifications--cards may have been
+        modified directly without the header containing it otherwise knowing.
+        """
+
+        modified_cards = any(c._modified for c in self._cards)
+        if modified_cards:
+            # If any cards were modified then by definition the header was
+            # modified
+            self.__dict__['_modified'] = True
+
+        return self.__dict__['_modified']
+
+    @_modified.setter
+    def _modified(self, val):
+        self.__dict__['_modified'] = val
+
+    @classmethod
+    def fromstring(cls, data, sep=''):
+        """
+        Creates an HDU header from a byte string containing the entire header
+        data.
+
+        Parameters
+        ----------
+        data : str or bytes
+           String or bytes containing the entire header.  In the case of bytes
+           they will be decoded using latin-1 (only plain ASCII characters are
+           allowed in FITS headers but latin-1 allows us to retain any invalid
+           bytes that might appear in malformatted FITS files).
+
+        sep : str, optional
+            The string separating cards from each other, such as a newline.  By
+            default there is no card separator (as is the case in a raw FITS
+            file).  In general this is only used in cases where a header was
+            printed as text (e.g. with newlines after each card) and you want
+            to create a new `Header` from it by copy/pasting.
+
+        Examples
+        --------
+
+        >>> from astropy.io.fits import Header
+        >>> hdr = Header({'SIMPLE': True})
+        >>> Header.fromstring(hdr.tostring()) == hdr
+        True
+
+        If you want to create a `Header` from printed text it's not necessary
+        to have the exact binary structure as it would appear in a FITS file,
+        with the full 80 byte card length.  Rather, each "card" can end in a
+        newline and does not have to be padded out to a full card length as
+        long as it "looks like" a FITS header:
+
+        >>> hdr = Header.fromstring(\"\"\"\\
+        ... SIMPLE  =                    T / conforms to FITS standard
+        ... BITPIX  =                    8 / array data type
+        ... NAXIS   =                    0 / number of array dimensions
+        ... EXTEND  =                    T
+        ... \"\"\", sep='\\n')
+        >>> hdr['SIMPLE']
+        True
+        >>> hdr['BITPIX']
+        8
+        >>> len(hdr)
+        4
+
+        Returns
+        -------
+        header
+            A new `Header` instance.
+        """
+
+        cards = []
+
+        # If the card separator contains characters that may validly appear in
+        # a card, the only way to unambiguously distinguish between cards is to
+        # require that they be Card.length long.  However, if the separator
+        # contains non-valid characters (namely \n) the cards may be split
+        # immediately at the separator
+        require_full_cardlength = set(sep).issubset(VALID_HEADER_CHARS)
+
+        if isinstance(data, bytes):
+            # FITS supports only ASCII, but decode as latin1 and just take all
+            # bytes for now; if it results in mojibake due to e.g. UTF-8
+            # encoded data in a FITS header that's OK because it shouldn't be
+            # there in the first place--accepting it here still gives us the
+            # opportunity to display warnings later during validation
+            CONTINUE = b'CONTINUE'
+            END = b'END'
+            end_card = END_CARD.encode('ascii')
+            sep = sep.encode('latin1')
+            empty = b''
+        else:
+            CONTINUE = 'CONTINUE'
+            END = 'END'
+            end_card = END_CARD
+            empty = ''
+
+        # Split the header into individual cards
+        idx = 0
+        image = []
+
+        while idx < len(data):
+            if require_full_cardlength:
+                end_idx = idx + Card.length
+            else:
+                try:
+                    end_idx = data.index(sep, idx)
+                except ValueError:
+                    end_idx = len(data)
+
+            next_image = data[idx:end_idx]
+            idx = end_idx + len(sep)
+
+            if image:
+                if next_image[:8] == CONTINUE:
+                    image.append(next_image)
+                    continue
+                cards.append(Card.fromstring(empty.join(image)))
+
+            if require_full_cardlength:
+                if next_image == end_card:
+                    image = []
+                    break
+            else:
+                if next_image.split(sep)[0].rstrip() == END:
+                    image = []
+                    break
+
+            image = [next_image]
+
+        # Add the last image that was found before the end, if any
+        if image:
+            cards.append(Card.fromstring(empty.join(image)))
+
+        return cls._fromcards(cards)
+
+    @classmethod
+    def fromfile(cls, fileobj, sep='', endcard=True, padding=True):
+        """
+        Similar to :meth:`Header.fromstring`, but reads the header string from
+        a given file-like object or filename.
+
+        Parameters
+        ----------
+        fileobj : str, file-like
+            A filename or an open file-like object from which a FITS header is
+            to be read.  For open file handles the file pointer must be at the
+            beginning of the header.
+
+        sep : str, optional
+            The string separating cards from each other, such as a newline.  By
+            default there is no card separator (as is the case in a raw FITS
+            file).
+
+        endcard : bool, optional
+            If True (the default) the header must end with an END card in order
+            to be considered valid.  If an END card is not found an
+            `OSError` is raised.
+
+        padding : bool, optional
+            If True (the default) the header will be required to be padded out
+            to a multiple of 2880, the FITS header block size.  Otherwise any
+            padding, or lack thereof, is ignored.
+
+        Returns
+        -------
+        header
+            A new `Header` instance.
+        """
+
+        close_file = False
+
+        if isinstance(fileobj, path_like):
+            # If sep is non-empty we are trying to read a header printed to a
+            # text file, so open in text mode by default to support newline
+            # handling; if a binary-mode file object is passed in, the user is
+            # then on their own w.r.t. newline handling.
+            #
+            # Otherwise assume we are reading from an actual FITS file and open
+            # in binary mode.
+            if sep:
+                fileobj = open(fileobj, 'r', encoding='latin1')
+            else:
+                fileobj = open(fileobj, 'rb')
+
+            close_file = True
+
+        try:
+            is_binary = fileobj_is_binary(fileobj)
+
+            def block_iter(nbytes):
+                while True:
+                    data = fileobj.read(nbytes)
+
+                    if data:
+                        yield data
+                    else:
+                        break
+
+            return cls._from_blocks(block_iter, is_binary, sep, endcard,
+                                    padding)[1]
+        finally:
+            if close_file:
+                fileobj.close()
+
+    @classmethod
+    def _fromcards(cls, cards):
+        header = cls()
+        for idx, card in enumerate(cards):
+            header._cards.append(card)
+            keyword = Card.normalize_keyword(card.keyword)
+            header._keyword_indices[keyword].append(idx)
+            if card.field_specifier is not None:
+                header._rvkc_indices[card.rawkeyword].append(idx)
+
+        header._modified = False
+        return header
+
+    @classmethod
+    def _from_blocks(cls, block_iter, is_binary, sep, endcard, padding):
+        """
+        The meat of `Header.fromfile`; in a separate method so that
+        `Header.fromfile` itself is just responsible for wrapping file
+        handling.  Also used by `_BaseHDU.fromstring`.
+
+        ``block_iter`` should be a callable which, given a block size n
+        (typically 2880 bytes as used by the FITS standard) returns an iterator
+        of byte strings of that block size.
+
+        ``is_binary`` specifies whether the returned blocks are bytes or text
+
+        Returns both the entire header *string*, and the `Header` object
+        returned by Header.fromstring on that string.
+        """
+
+        actual_block_size = _block_size(sep)
+        clen = Card.length + len(sep)
+
+        blocks = block_iter(actual_block_size)
+
+        # Read the first header block.
+        try:
+            block = next(blocks)
+        except StopIteration:
+            raise EOFError()
+
+        if not is_binary:
+            # TODO: There needs to be error handling at *this* level for
+            # non-ASCII characters; maybe at this stage decoding latin-1 might
+            # be safer
+            block = encode_ascii(block)
+
+        read_blocks = []
+        is_eof = False
+        end_found = False
+
+        # continue reading header blocks until END card or EOF is reached
+        while True:
+            # find the END card
+            end_found, block = cls._find_end_card(block, clen)
+
+            read_blocks.append(decode_ascii(block))
+
+            if end_found:
+                break
+
+            try:
+                block = next(blocks)
+            except StopIteration:
+                is_eof = True
+                break
+
+            if not block:
+                is_eof = True
+                break
+
+            if not is_binary:
+                block = encode_ascii(block)
+
+        if not end_found and is_eof and endcard:
+            # TODO: Pass this error to validation framework as an ERROR,
+            # rather than raising an exception
+            raise OSError('Header missing END card.')
+
+        header_str = ''.join(read_blocks)
+        _check_padding(header_str, actual_block_size, is_eof,
+                       check_block_size=padding)
+
+        return header_str, cls.fromstring(header_str, sep=sep)
+
+    @classmethod
+    def _find_end_card(cls, block, card_len):
+        """
+        Utility method to search a header block for the END card and handle
+        invalid END cards.
+
+        This method can also returned a modified copy of the input header block
+        in case an invalid end card needs to be sanitized.
+        """
+
+        for mo in HEADER_END_RE.finditer(block):
+            # Ensure the END card was found, and it started on the
+            # boundary of a new card (see ticket #142)
+            if mo.start() % card_len != 0:
+                continue
+
+            # This must be the last header block, otherwise the
+            # file is malformatted
+            if mo.group('invalid'):
+                offset = mo.start()
+                trailing = block[offset + 3:offset + card_len - 3].rstrip()
+                if trailing:
+                    trailing = repr(trailing).lstrip('ub')
+                    # TODO: Pass this warning up to the validation framework
+                    warnings.warn(
+                        'Unexpected bytes trailing END keyword: {0}; these '
+                        'bytes will be replaced with spaces on write.'.format(
+                            trailing), AstropyUserWarning)
+                else:
+                    # TODO: Pass this warning up to the validation framework
+                    warnings.warn(
+                        'Missing padding to end of the FITS block after the '
+                        'END keyword; additional spaces will be appended to '
+                        'the file upon writing to pad out to {0} '
+                        'bytes.'.format(BLOCK_SIZE), AstropyUserWarning)
+
+                # Sanitize out invalid END card now that the appropriate
+                # warnings have been issued
+                block = (block[:offset] + encode_ascii(END_CARD) +
+                         block[offset + len(END_CARD):])
+
+            return True, block
+
+        return False, block
+
+    def tostring(self, sep='', endcard=True, padding=True):
+        r"""
+        Returns a string representation of the header.
+
+        By default this uses no separator between cards, adds the END card, and
+        pads the string with spaces to the next multiple of 2880 bytes.  That
+        is, it returns the header exactly as it would appear in a FITS file.
+
+        Parameters
+        ----------
+        sep : str, optional
+            The character or string with which to separate cards.  By default
+            there is no separator, but one could use ``'\\n'``, for example, to
+            separate each card with a new line
+
+        endcard : bool, optional
+            If True (default) adds the END card to the end of the header
+            string
+
+        padding : bool, optional
+            If True (default) pads the string with spaces out to the next
+            multiple of 2880 characters
+
+        Returns
+        -------
+        s : str
+            A string representing a FITS header.
+        """
+
+        lines = []
+        for card in self._cards:
+            s = str(card)
+            # Cards with CONTINUE cards may be longer than 80 chars; so break
+            # them into multiple lines
+            while s:
+                lines.append(s[:Card.length])
+                s = s[Card.length:]
+
+        s = sep.join(lines)
+        if endcard:
+            s += sep + _pad('END')
+        if padding:
+            s += ' ' * _pad_length(len(s))
+        return s
+
+    @deprecated_renamed_argument('clobber', 'overwrite', '2.0')
+    def tofile(self, fileobj, sep='', endcard=True, padding=True,
+               overwrite=False):
+        r"""
+        Writes the header to file or file-like object.
+
+        By default this writes the header exactly as it would be written to a
+        FITS file, with the END card included and padding to the next multiple
+        of 2880 bytes.  However, aspects of this may be controlled.
+
+        Parameters
+        ----------
+        fileobj : str, file, optional
+            Either the pathname of a file, or an open file handle or file-like
+            object
+
+        sep : str, optional
+            The character or string with which to separate cards.  By default
+            there is no separator, but one could use ``'\\n'``, for example, to
+            separate each card with a new line
+
+        endcard : bool, optional
+            If `True` (default) adds the END card to the end of the header
+            string
+
+        padding : bool, optional
+            If `True` (default) pads the string with spaces out to the next
+            multiple of 2880 characters
+
+        overwrite : bool, optional
+            If ``True``, overwrite the output file if it exists. Raises an
+            ``OSError`` if ``False`` and the output file exists. Default is
+            ``False``.
+
+            .. versionchanged:: 1.3
+               ``overwrite`` replaces the deprecated ``clobber`` argument.
+        """
+
+        close_file = fileobj_closed(fileobj)
+
+        if not isinstance(fileobj, _File):
+            fileobj = _File(fileobj, mode='ostream', overwrite=overwrite)
+
+        try:
+            blocks = self.tostring(sep=sep, endcard=endcard, padding=padding)
+            actual_block_size = _block_size(sep)
+            if padding and len(blocks) % actual_block_size != 0:
+                raise OSError(
+                    'Header size ({}) is not a multiple of block '
+                    'size ({}).'.format(
+                        len(blocks) - actual_block_size + BLOCK_SIZE,
+                        BLOCK_SIZE))
+
+            if not fileobj.simulateonly:
+                fileobj.flush()
+                try:
+                    offset = fileobj.tell()
+                except (AttributeError, OSError):
+                    offset = 0
+                fileobj.write(blocks.encode('ascii'))
+                fileobj.flush()
+        finally:
+            if close_file:
+                fileobj.close()
+
+    @classmethod
+    def fromtextfile(cls, fileobj, endcard=False):
+        """
+        Read a header from a simple text file or file-like object.
+
+        Equivalent to::
+
+            >>> Header.fromfile(fileobj, sep='\\n', endcard=False,
+            ...                 padding=False)
+
+        See Also
+        --------
+        fromfile
+        """
+
+        return cls.fromfile(fileobj, sep='\n', endcard=endcard, padding=False)
+
+    @deprecated_renamed_argument('clobber', 'overwrite', '2.0')
+    def totextfile(self, fileobj, endcard=False, overwrite=False):
+        """
+        Write the header as text to a file or a file-like object.
+
+        Equivalent to::
+
+            >>> Header.tofile(fileobj, sep='\\n', endcard=False,
+            ...               padding=False, overwrite=overwrite)
+
+        .. versionchanged:: 1.3
+           ``overwrite`` replaces the deprecated ``clobber`` argument.
+
+        See Also
+        --------
+        tofile
+        """
+
+        self.tofile(fileobj, sep='\n', endcard=endcard, padding=False,
+                    overwrite=overwrite)
+
+    def clear(self):
+        """
+        Remove all cards from the header.
+        """
+
+        self._cards = []
+        self._keyword_indices = collections.defaultdict(list)
+        self._rvkc_indices = collections.defaultdict(list)
+
+    def copy(self, strip=False):
+        """
+        Make a copy of the :class:`Header`.
+
+        .. versionchanged:: 1.3
+            `copy.copy` and `copy.deepcopy` on a `Header` will call this
+            method.
+
+        Parameters
+        ----------
+        strip : bool, optional
+           If `True`, strip any headers that are specific to one of the
+           standard HDU types, so that this header can be used in a different
+           HDU.
+
+        Returns
+        -------
+        header
+            A new :class:`Header` instance.
+        """
+
+        tmp = Header((copy.copy(card) for card in self._cards))
+        if strip:
+            tmp._strip()
+        return tmp
+
+    def __copy__(self):
+        return self.copy()
+
+    def __deepcopy__(self, *args, **kwargs):
+        return self.copy()
+
+    @classmethod
+    def fromkeys(cls, iterable, value=None):
+        """
+        Similar to :meth:`dict.fromkeys`--creates a new `Header` from an
+        iterable of keywords and an optional default value.
+
+        This method is not likely to be particularly useful for creating real
+        world FITS headers, but it is useful for testing.
+
+        Parameters
+        ----------
+        iterable
+            Any iterable that returns strings representing FITS keywords.
+
+        value : optional
+            A default value to assign to each keyword; must be a valid type for
+            FITS keywords.
+
+        Returns
+        -------
+        header
+            A new `Header` instance.
+        """
+
+        d = cls()
+        if not isinstance(value, tuple):
+            value = (value,)
+        for key in iterable:
+            d.append((key,) + value)
+        return d
+
+    def get(self, key, default=None):
+        """
+        Similar to :meth:`dict.get`--returns the value associated with keyword
+        in the header, or a default value if the keyword is not found.
+
+        Parameters
+        ----------
+        key : str
+            A keyword that may or may not be in the header.
+
+        default : optional
+            A default value to return if the keyword is not found in the
+            header.
+
+        Returns
+        -------
+        value
+            The value associated with the given keyword, or the default value
+            if the keyword is not in the header.
+        """
+
+        try:
+            return self[key]
+        except (KeyError, IndexError):
+            return default
+
+    def set(self, keyword, value=None, comment=None, before=None, after=None):
+        """
+        Set the value and/or comment and/or position of a specified keyword.
+
+        If the keyword does not already exist in the header, a new keyword is
+        created in the specified position, or appended to the end of the header
+        if no position is specified.
+
+        This method is similar to :meth:`Header.update` prior to Astropy v0.1.
+
+        .. note::
+            It should be noted that ``header.set(keyword, value)`` and
+            ``header.set(keyword, value, comment)`` are equivalent to
+            ``header[keyword] = value`` and
+            ``header[keyword] = (value, comment)`` respectively.
+
+            New keywords can also be inserted relative to existing keywords
+            using, for example::
+
+                >>> header.insert('NAXIS1', ('NAXIS', 2, 'Number of axes'))
+
+            to insert before an existing keyword, or::
+
+                >>> header.insert('NAXIS', ('NAXIS1', 4096), after=True)
+
+            to insert after an existing keyword.
+
+            The only advantage of using :meth:`Header.set` is that it
+            easily replaces the old usage of :meth:`Header.update` both
+            conceptually and in terms of function signature.
+
+        Parameters
+        ----------
+        keyword : str
+            A header keyword
+
+        value : str, optional
+            The value to set for the given keyword; if None the existing value
+            is kept, but '' may be used to set a blank value
+
+        comment : str, optional
+            The comment to set for the given keyword; if None the existing
+            comment is kept, but ``''`` may be used to set a blank comment
+
+        before : str, int, optional
+            Name of the keyword, or index of the `Card` before which this card
+            should be located in the header.  The argument ``before`` takes
+            precedence over ``after`` if both specified.
+
+        after : str, int, optional
+            Name of the keyword, or index of the `Card` after which this card
+            should be located in the header.
+
+        """
+
+        # Create a temporary card that looks like the one being set; if the
+        # temporary card turns out to be a RVKC this will make it easier to
+        # deal with the idiosyncrasies thereof
+        # Don't try to make a temporary card though if they keyword looks like
+        # it might be a HIERARCH card or is otherwise invalid--this step is
+        # only for validating RVKCs.
+        if (len(keyword) <= KEYWORD_LENGTH and
+            Card._keywd_FSC_RE.match(keyword) and
+                keyword not in self._keyword_indices):
+            new_card = Card(keyword, value, comment)
+            new_keyword = new_card.keyword
+        else:
+            new_keyword = keyword
+
+        if (new_keyword not in Card._commentary_keywords and
+                new_keyword in self):
+            if comment is None:
+                comment = self.comments[keyword]
+            if value is None:
+                value = self[keyword]
+
+            self[keyword] = (value, comment)
+
+            if before is not None or after is not None:
+                card = self._cards[self._cardindex(keyword)]
+                self._relativeinsert(card, before=before, after=after,
+                                     replace=True)
+        elif before is not None or after is not None:
+            self._relativeinsert((keyword, value, comment), before=before,
+                                 after=after)
+        else:
+            self[keyword] = (value, comment)
+
+    def items(self):
+        """Like :meth:`dict.items`."""
+
+        for card in self._cards:
+            yield (card.keyword, card.value)
+
+    def keys(self):
+        """
+        Like :meth:`dict.keys`--iterating directly over the `Header`
+        instance has the same behavior.
+        """
+
+        for card in self._cards:
+            yield card.keyword
+
+    def values(self):
+        """Like :meth:`dict.values`."""
+
+        for card in self._cards:
+            yield card.value
+
+    def pop(self, *args):
+        """
+        Works like :meth:`list.pop` if no arguments or an index argument are
+        supplied; otherwise works like :meth:`dict.pop`.
+        """
+
+        if len(args) > 2:
+            raise TypeError('Header.pop expected at most 2 arguments, got '
+                            '{}'.format(len(args)))
+
+        if len(args) == 0:
+            key = -1
+        else:
+            key = args[0]
+
+        try:
+            value = self[key]
+        except (KeyError, IndexError):
+            if len(args) == 2:
+                return args[1]
+            raise
+
+        del self[key]
+        return value
+
+    def popitem(self):
+        """Similar to :meth:`dict.popitem`."""
+
+        try:
+            k, v = next(self.items())
+        except StopIteration:
+            raise KeyError('Header is empty')
+        del self[k]
+        return k, v
+
+    def setdefault(self, key, default=None):
+        """Similar to :meth:`dict.setdefault`."""
+
+        try:
+            return self[key]
+        except (KeyError, IndexError):
+            self[key] = default
+        return default
+
+    def update(self, *args, **kwargs):
+        """
+        Update the Header with new keyword values, updating the values of
+        existing keywords and appending new keywords otherwise; similar to
+        `dict.update`.
+
+        `update` accepts either a dict-like object or an iterable.  In the
+        former case the keys must be header keywords and the values may be
+        either scalar values or (value, comment) tuples.  In the case of an
+        iterable the items must be (keyword, value) tuples or (keyword, value,
+        comment) tuples.
+
+        Arbitrary arguments are also accepted, in which case the update() is
+        called again with the kwargs dict as its only argument.  That is,
+
+        ::
+
+            >>> header.update(NAXIS1=100, NAXIS2=100)
+
+        is equivalent to::
+
+            header.update({'NAXIS1': 100, 'NAXIS2': 100})
+
+        .. warning::
+            As this method works similarly to `dict.update` it is very
+            different from the ``Header.update()`` method in Astropy v0.1.
+            Use of the old API was
+            **deprecated** for a long time and is now removed. Most uses of the
+            old API can be replaced as follows:
+
+            * Replace ::
+
+                  header.update(keyword, value)
+
+              with ::
+
+                  header[keyword] = value
+
+            * Replace ::
+
+                  header.update(keyword, value, comment=comment)
+
+              with ::
+
+                  header[keyword] = (value, comment)
+
+            * Replace ::
+
+                  header.update(keyword, value, before=before_keyword)
+
+              with ::
+
+                  header.insert(before_keyword, (keyword, value))
+
+            * Replace ::
+
+                  header.update(keyword, value, after=after_keyword)
+
+              with ::
+
+                  header.insert(after_keyword, (keyword, value),
+                                after=True)
+
+            See also :meth:`Header.set` which is a new method that provides an
+            interface similar to the old ``Header.update()`` and may help make
+            transition a little easier.
+
+        """
+
+        if args:
+            other = args[0]
+        else:
+            other = None
+
+        def update_from_dict(k, v):
+            if not isinstance(v, tuple):
+                card = Card(k, v)
+            elif 0 < len(v) <= 2:
+                card = Card(*((k,) + v))
+            else:
+                raise ValueError(
+                    'Header update value for key %r is invalid; the '
+                    'value must be either a scalar, a 1-tuple '
+                    'containing the scalar value, or a 2-tuple '
+                    'containing the value and a comment string.' % k)
+            self._update(card)
+
+        if other is None:
+            pass
+        elif isinstance(other, Header):
+            for card in other.cards:
+                self._update(card)
+        elif hasattr(other, 'items'):
+            for k, v in other.items():
+                update_from_dict(k, v)
+        elif hasattr(other, 'keys'):
+            for k in other.keys():
+                update_from_dict(k, other[k])
+        else:
+            for idx, card in enumerate(other):
+                if isinstance(card, Card):
+                    self._update(card)
+                elif isinstance(card, tuple) and (1 < len(card) <= 3):
+                    self._update(Card(*card))
+                else:
+                    raise ValueError(
+                        'Header update sequence item #{} is invalid; '
+                        'the item must either be a 2-tuple containing '
+                        'a keyword and value, or a 3-tuple containing '
+                        'a keyword, value, and comment string.'.format(idx))
+        if kwargs:
+            self.update(kwargs)
+
+    def append(self, card=None, useblanks=True, bottom=False, end=False):
+        """
+        Appends a new keyword+value card to the end of the Header, similar
+        to `list.append`.
+
+        By default if the last cards in the Header have commentary keywords,
+        this will append the new keyword before the commentary (unless the new
+        keyword is also commentary).
+
+        Also differs from `list.append` in that it can be called with no
+        arguments: In this case a blank card is appended to the end of the
+        Header.  In the case all the keyword arguments are ignored.
+
+        Parameters
+        ----------
+        card : str, tuple
+            A keyword or a (keyword, value, [comment]) tuple representing a
+            single header card; the comment is optional in which case a
+            2-tuple may be used
+
+        useblanks : bool, optional
+            If there are blank cards at the end of the Header, replace the
+            first blank card so that the total number of cards in the Header
+            does not increase.  Otherwise preserve the number of blank cards.
+
+        bottom : bool, optional
+            If True, instead of appending after the last non-commentary card,
+            append after the last non-blank card.
+
+        end : bool, optional
+            If True, ignore the useblanks and bottom options, and append at the
+            very end of the Header.
+
+        """
+
+        if isinstance(card, str):
+            card = Card(card)
+        elif isinstance(card, tuple):
+            card = Card(*card)
+        elif card is None:
+            card = Card()
+        elif not isinstance(card, Card):
+            raise ValueError(
+                'The value appended to a Header must be either a keyword or '
+                '(keyword, value, [comment]) tuple; got: {!r}'.format(card))
+
+        if not end and card.is_blank:
+            # Blank cards should always just be appended to the end
+            end = True
+
+        if end:
+            self._cards.append(card)
+            idx = len(self._cards) - 1
+        else:
+            idx = len(self._cards) - 1
+            while idx >= 0 and self._cards[idx].is_blank:
+                idx -= 1
+
+            if not bottom and card.keyword not in Card._commentary_keywords:
+                while (idx >= 0 and
+                       self._cards[idx].keyword in Card._commentary_keywords):
+                    idx -= 1
+
+            idx += 1
+            self._cards.insert(idx, card)
+            self._updateindices(idx)
+
+        keyword = Card.normalize_keyword(card.keyword)
+        self._keyword_indices[keyword].append(idx)
+        if card.field_specifier is not None:
+            self._rvkc_indices[card.rawkeyword].append(idx)
+
+        if not end:
+            # If the appended card was a commentary card, and it was appended
+            # before existing cards with the same keyword, the indices for
+            # cards with that keyword may have changed
+            if not bottom and card.keyword in Card._commentary_keywords:
+                self._keyword_indices[keyword].sort()
+
+            # Finally, if useblanks, delete a blank cards from the end
+            if useblanks and self._countblanks():
+                # Don't do this unless there is at least one blanks at the end
+                # of the header; we need to convert the card to its string
+                # image to see how long it is.  In the vast majority of cases
+                # this will just be 80 (Card.length) but it may be longer for
+                # CONTINUE cards
+                self._useblanks(len(str(card)) // Card.length)
+
+        self._modified = True
+
+    def extend(self, cards, strip=True, unique=False, update=False,
+               update_first=False, useblanks=True, bottom=False, end=False):
+        """
+        Appends multiple keyword+value cards to the end of the header, similar
+        to `list.extend`.
+
+        Parameters
+        ----------
+        cards : iterable
+            An iterable of (keyword, value, [comment]) tuples; see
+            `Header.append`.
+
+        strip : bool, optional
+            Remove any keywords that have meaning only to specific types of
+            HDUs, so that only more general keywords are added from extension
+            Header or Card list (default: `True`).
+
+        unique : bool, optional
+            If `True`, ensures that no duplicate keywords are appended;
+            keywords already in this header are simply discarded.  The
+            exception is commentary keywords (COMMENT, HISTORY, etc.): they are
+            only treated as duplicates if their values match.
+
+        update : bool, optional
+            If `True`, update the current header with the values and comments
+            from duplicate keywords in the input header.  This supersedes the
+            ``unique`` argument.  Commentary keywords are treated the same as
+            if ``unique=True``.
+
+        update_first : bool, optional
+            If the first keyword in the header is 'SIMPLE', and the first
+            keyword in the input header is 'XTENSION', the 'SIMPLE' keyword is
+            replaced by the 'XTENSION' keyword.  Likewise if the first keyword
+            in the header is 'XTENSION' and the first keyword in the input
+            header is 'SIMPLE', the 'XTENSION' keyword is replaced by the
+            'SIMPLE' keyword.  This behavior is otherwise dumb as to whether or
+            not the resulting header is a valid primary or extension header.
+            This is mostly provided to support backwards compatibility with the
+            old ``Header.fromTxtFile`` method, and only applies if
+            ``update=True``.
+
+        useblanks, bottom, end : bool, optional
+            These arguments are passed to :meth:`Header.append` while appending
+            new cards to the header.
+        """
+
+        temp = Header(cards)
+        if strip:
+            temp._strip()
+
+        if len(self):
+            first = self._cards[0].keyword
+        else:
+            first = None
+
+        # We don't immediately modify the header, because first we need to sift
+        # out any duplicates in the new header prior to adding them to the
+        # existing header, but while *allowing* duplicates from the header
+        # being extended from (see ticket #156)
+        extend_cards = []
+
+        for idx, card in enumerate(temp.cards):
+            keyword = card.keyword
+            if keyword not in Card._commentary_keywords:
+                if unique and not update and keyword in self:
+                    continue
+                elif update:
+                    if idx == 0 and update_first:
+                        # Dumbly update the first keyword to either SIMPLE or
+                        # XTENSION as the case may be, as was in the case in
+                        # Header.fromTxtFile
+                        if ((keyword == 'SIMPLE' and first == 'XTENSION') or
+                                (keyword == 'XTENSION' and first == 'SIMPLE')):
+                            del self[0]
+                            self.insert(0, card)
+                        else:
+                            self[keyword] = (card.value, card.comment)
+                    elif keyword in self:
+                        self[keyword] = (card.value, card.comment)
+                    else:
+                        extend_cards.append(card)
+                else:
+                    extend_cards.append(card)
+            else:
+                if (unique or update) and keyword in self:
+                    if card.is_blank:
+                        extend_cards.append(card)
+                        continue
+
+                    for value in self[keyword]:
+                        if value == card.value:
+                            break
+                    else:
+                        extend_cards.append(card)
+                else:
+                    extend_cards.append(card)
+
+        for card in extend_cards:
+            self.append(card, useblanks=useblanks, bottom=bottom, end=end)
+
+    def count(self, keyword):
+        """
+        Returns the count of the given keyword in the header, similar to
+        `list.count` if the Header object is treated as a list of keywords.
+
+        Parameters
+        ----------
+        keyword : str
+            The keyword to count instances of in the header
+
+        """
+
+        keyword = Card.normalize_keyword(keyword)
+
+        # We have to look before we leap, since otherwise _keyword_indices,
+        # being a defaultdict, will create an entry for the nonexistent keyword
+        if keyword not in self._keyword_indices:
+            raise KeyError("Keyword {!r} not found.".format(keyword))
+
+        return len(self._keyword_indices[keyword])
+
+    def index(self, keyword, start=None, stop=None):
+        """
+        Returns the index if the first instance of the given keyword in the
+        header, similar to `list.index` if the Header object is treated as a
+        list of keywords.
+
+        Parameters
+        ----------
+        keyword : str
+            The keyword to look up in the list of all keywords in the header
+
+        start : int, optional
+            The lower bound for the index
+
+        stop : int, optional
+            The upper bound for the index
+
+        """
+
+        if start is None:
+            start = 0
+
+        if stop is None:
+            stop = len(self._cards)
+
+        if stop < start:
+            step = -1
+        else:
+            step = 1
+
+        norm_keyword = Card.normalize_keyword(keyword)
+
+        for idx in range(start, stop, step):
+            if self._cards[idx].keyword.upper() == norm_keyword:
+                return idx
+        else:
+            raise ValueError('The keyword {!r} is not in the '
+                             ' header.'.format(keyword))
+
+    def insert(self, key, card, useblanks=True, after=False):
+        """
+        Inserts a new keyword+value card into the Header at a given location,
+        similar to `list.insert`.
+
+        Parameters
+        ----------
+        key : int, str, or tuple
+            The index into the list of header keywords before which the
+            new keyword should be inserted, or the name of a keyword before
+            which the new keyword should be inserted.  Can also accept a
+            (keyword, index) tuple for inserting around duplicate keywords.
+
+        card : str, tuple
+            A keyword or a (keyword, value, [comment]) tuple; see
+            `Header.append`
+
+        useblanks : bool, optional
+            If there are blank cards at the end of the Header, replace the
+            first blank card so that the total number of cards in the Header
+            does not increase.  Otherwise preserve the number of blank cards.
+
+        after : bool, optional
+            If set to `True`, insert *after* the specified index or keyword,
+            rather than before it.  Defaults to `False`.
+        """
+
+        if not isinstance(key, int):
+            # Don't pass through ints to _cardindex because it will not take
+            # kindly to indices outside the existing number of cards in the
+            # header, which insert needs to be able to support (for example
+            # when inserting into empty headers)
+            idx = self._cardindex(key)
+        else:
+            idx = key
+
+        if after:
+            if idx == -1:
+                idx = len(self._cards)
+            else:
+                idx += 1
+
+        if idx >= len(self._cards):
+            # This is just an append (Though it must be an append absolutely to
+            # the bottom, ignoring blanks, etc.--the point of the insert method
+            # is that you get exactly what you asked for with no surprises)
+            self.append(card, end=True)
+            return
+
+        if isinstance(card, str):
+            card = Card(card)
+        elif isinstance(card, tuple):
+            card = Card(*card)
+        elif not isinstance(card, Card):
+            raise ValueError(
+                'The value inserted into a Header must be either a keyword or '
+                '(keyword, value, [comment]) tuple; got: {!r}'.format(card))
+
+        self._cards.insert(idx, card)
+
+        keyword = card.keyword
+
+        # If idx was < 0, determine the actual index according to the rules
+        # used by list.insert()
+        if idx < 0:
+            idx += len(self._cards) - 1
+            if idx < 0:
+                idx = 0
+
+        # All the keyword indices above the insertion point must be updated
+        self._updateindices(idx)
+
+        keyword = Card.normalize_keyword(keyword)
+        self._keyword_indices[keyword].append(idx)
+        count = len(self._keyword_indices[keyword])
+        if count > 1:
+            # There were already keywords with this same name
+            if keyword not in Card._commentary_keywords:
+                warnings.warn(
+                    'A {!r} keyword already exists in this header.  Inserting '
+                    'duplicate keyword.'.format(keyword), AstropyUserWarning)
+            self._keyword_indices[keyword].sort()
+
+        if card.field_specifier is not None:
+            # Update the index of RVKC as well
+            rvkc_indices = self._rvkc_indices[card.rawkeyword]
+            rvkc_indices.append(idx)
+            rvkc_indices.sort()
+
+        if useblanks:
+            self._useblanks(len(str(card)) // Card.length)
+
+        self._modified = True
+
+    def remove(self, keyword, ignore_missing=False, remove_all=False):
+        """
+        Removes the first instance of the given keyword from the header similar
+        to `list.remove` if the Header object is treated as a list of keywords.
+
+        Parameters
+        ----------
+        keyword : str
+            The keyword of which to remove the first instance in the header.
+
+        ignore_missing : bool, optional
+            When True, ignores missing keywords.  Otherwise, if the keyword
+            is not present in the header a KeyError is raised.
+
+        remove_all : bool, optional
+            When True, all instances of keyword will be removed.
+            Otherwise only the first instance of the given keyword is removed.
+
+        """
+        keyword = Card.normalize_keyword(keyword)
+        if keyword in self._keyword_indices:
+            del self[self._keyword_indices[keyword][0]]
+            if remove_all:
+                while keyword in self._keyword_indices:
+                    del self[self._keyword_indices[keyword][0]]
+        elif not ignore_missing:
+            raise KeyError("Keyword '{}' not found.".format(keyword))
+
+    def rename_keyword(self, oldkeyword, newkeyword, force=False):
+        """
+        Rename a card's keyword in the header.
+
+        Parameters
+        ----------
+        oldkeyword : str or int
+            Old keyword or card index
+
+        newkeyword : str
+            New keyword
+
+        force : bool, optional
+            When `True`, if the new keyword already exists in the header, force
+            the creation of a duplicate keyword. Otherwise a
+            `ValueError` is raised.
+        """
+
+        oldkeyword = Card.normalize_keyword(oldkeyword)
+        newkeyword = Card.normalize_keyword(newkeyword)
+
+        if newkeyword == 'CONTINUE':
+            raise ValueError('Can not rename to CONTINUE')
+
+        if (newkeyword in Card._commentary_keywords or
+                oldkeyword in Card._commentary_keywords):
+            if not (newkeyword in Card._commentary_keywords and
+                    oldkeyword in Card._commentary_keywords):
+                raise ValueError('Regular and commentary keys can not be '
+                                 'renamed to each other.')
+        elif not force and newkeyword in self:
+            raise ValueError('Intended keyword {} already exists in header.'
+                             .format(newkeyword))
+
+        idx = self.index(oldkeyword)
+        card = self._cards[idx]
+        del self[idx]
+        self.insert(idx, (newkeyword, card.value, card.comment))
+
+    def add_history(self, value, before=None, after=None):
+        """
+        Add a ``HISTORY`` card.
+
+        Parameters
+        ----------
+        value : str
+            History text to be added.
+
+        before : str or int, optional
+            Same as in `Header.update`
+
+        after : str or int, optional
+            Same as in `Header.update`
+        """
+
+        self._add_commentary('HISTORY', value, before=before, after=after)
+
+    def add_comment(self, value, before=None, after=None):
+        """
+        Add a ``COMMENT`` card.
+
+        Parameters
+        ----------
+        value : str
+            Text to be added.
+
+        before : str or int, optional
+            Same as in `Header.update`
+
+        after : str or int, optional
+            Same as in `Header.update`
+        """
+
+        self._add_commentary('COMMENT', value, before=before, after=after)
+
+    def add_blank(self, value='', before=None, after=None):
+        """
+        Add a blank card.
+
+        Parameters
+        ----------
+        value : str, optional
+            Text to be added.
+
+        before : str or int, optional
+            Same as in `Header.update`
+
+        after : str or int, optional
+            Same as in `Header.update`
+        """
+
+        self._add_commentary('', value, before=before, after=after)
+
+    def _update(self, card):
+        """
+        The real update code.  If keyword already exists, its value and/or
+        comment will be updated.  Otherwise a new card will be appended.
+
+        This will not create a duplicate keyword except in the case of
+        commentary cards.  The only other way to force creation of a duplicate
+        is to use the insert(), append(), or extend() methods.
+        """
+
+        keyword, value, comment = card
+
+        # Lookups for existing/known keywords are case-insensitive
+        keyword = keyword.upper()
+        if keyword.startswith('HIERARCH '):
+            keyword = keyword[9:]
+
+        if (keyword not in Card._commentary_keywords and
+                keyword in self._keyword_indices):
+            # Easy; just update the value/comment
+            idx = self._keyword_indices[keyword][0]
+            existing_card = self._cards[idx]
+            existing_card.value = value
+            if comment is not None:
+                # '' should be used to explicitly blank a comment
+                existing_card.comment = comment
+            if existing_card._modified:
+                self._modified = True
+        elif keyword in Card._commentary_keywords:
+            cards = self._splitcommentary(keyword, value)
+            if keyword in self._keyword_indices:
+                # Append after the last keyword of the same type
+                idx = self.index(keyword, start=len(self) - 1, stop=-1)
+                isblank = not (keyword or value or comment)
+                for c in reversed(cards):
+                    self.insert(idx + 1, c, useblanks=(not isblank))
+            else:
+                for c in cards:
+                    self.append(c, bottom=True)
+        else:
+            # A new keyword! self.append() will handle updating _modified
+            self.append(card)
+
+    def _cardindex(self, key):
+        """Returns an index into the ._cards list given a valid lookup key."""
+
+        # This used to just set key = (key, 0) and then go on to act as if the
+        # user passed in a tuple, but it's much more common to just be given a
+        # string as the key, so optimize more for that case
+        if isinstance(key, str):
+            keyword = key
+            n = 0
+        elif isinstance(key, int):
+            # If < 0, determine the actual index
+            if key < 0:
+                key += len(self._cards)
+            if key < 0 or key >= len(self._cards):
+                raise IndexError('Header index out of range.')
+            return key
+        elif isinstance(key, slice):
+            return key
+        elif isinstance(key, tuple):
+            if (len(key) != 2 or not isinstance(key[0], str) or
+                    not isinstance(key[1], int)):
+                raise ValueError(
+                    'Tuple indices must be 2-tuples consisting of a '
+                    'keyword string and an integer index.')
+            keyword, n = key
+        else:
+            raise ValueError(
+                'Header indices must be either a string, a 2-tuple, or '
+                'an integer.')
+
+        keyword = Card.normalize_keyword(keyword)
+        # Returns the index into _cards for the n-th card with the given
+        # keyword (where n is 0-based)
+        indices = self._keyword_indices.get(keyword, None)
+
+        if keyword and not indices:
+            if len(keyword) > KEYWORD_LENGTH or '.' in keyword:
+                raise KeyError("Keyword {!r} not found.".format(keyword))
+            else:
+                # Maybe it's a RVKC?
+                indices = self._rvkc_indices.get(keyword, None)
+
+        if not indices:
+            raise KeyError("Keyword {!r} not found.".format(keyword))
+
+        try:
+            return indices[n]
+        except IndexError:
+            raise IndexError('There are only {} {!r} cards in the '
+                             'header.'.format(len(indices), keyword))
+
+    def _keyword_from_index(self, idx):
+        """
+        Given an integer index, return the (keyword, repeat) tuple that index
+        refers to.  For most keywords the repeat will always be zero, but it
+        may be greater than zero for keywords that are duplicated (especially
+        commentary keywords).
+
+        In a sense this is the inverse of self.index, except that it also
+        supports duplicates.
+        """
+
+        if idx < 0:
+            idx += len(self._cards)
+
+        keyword = self._cards[idx].keyword
+        keyword = Card.normalize_keyword(keyword)
+        repeat = self._keyword_indices[keyword].index(idx)
+        return keyword, repeat
+
+    def _relativeinsert(self, card, before=None, after=None, replace=False):
+        """
+        Inserts a new card before or after an existing card; used to
+        implement support for the legacy before/after keyword arguments to
+        Header.update().
+
+        If replace=True, move an existing card with the same keyword.
+        """
+
+        if before is None:
+            insertionkey = after
+        else:
+            insertionkey = before
+
+        def get_insertion_idx():
+            if not (isinstance(insertionkey, int) and
+                    insertionkey >= len(self._cards)):
+                idx = self._cardindex(insertionkey)
+            else:
+                idx = insertionkey
+
+            if before is None:
+                idx += 1
+
+            return idx
+
+        if replace:
+            # The card presumably already exists somewhere in the header.
+            # Check whether or not we actually have to move it; if it does need
+            # to be moved we just delete it and then it will be reinserted
+            # below
+            old_idx = self._cardindex(card.keyword)
+            insertion_idx = get_insertion_idx()
+
+            if (insertion_idx >= len(self._cards) and
+                    old_idx == len(self._cards) - 1):
+                # The card would be appended to the end, but it's already at
+                # the end
+                return
+
+            if before is not None:
+                if old_idx == insertion_idx - 1:
+                    return
+            elif after is not None and old_idx == insertion_idx:
+                return
+
+            del self[old_idx]
+
+        # Even if replace=True, the insertion idx may have changed since the
+        # old card was deleted
+        idx = get_insertion_idx()
+
+        if card[0] in Card._commentary_keywords:
+            cards = reversed(self._splitcommentary(card[0], card[1]))
+        else:
+            cards = [card]
+        for c in cards:
+            self.insert(idx, c)
+
+    def _updateindices(self, idx, increment=True):
+        """
+        For all cards with index above idx, increment or decrement its index
+        value in the keyword_indices dict.
+        """
+        if idx > len(self._cards):
+            # Save us some effort
+            return
+
+        increment = 1 if increment else -1
+
+        for index_sets in (self._keyword_indices, self._rvkc_indices):
+            for indices in index_sets.values():
+                for jdx, keyword_index in enumerate(indices):
+                    if keyword_index >= idx:
+                        indices[jdx] += increment
+
+    def _countblanks(self):
+        """Returns the number of blank cards at the end of the Header."""
+
+        for idx in range(1, len(self._cards)):
+            if not self._cards[-idx].is_blank:
+                return idx - 1
+        return 0
+
+    def _useblanks(self, count):
+        for _ in range(count):
+            if self._cards[-1].is_blank:
+                del self[-1]
+            else:
+                break
+
+    def _haswildcard(self, keyword):
+        """Return `True` if the input keyword contains a wildcard pattern."""
+
+        return (isinstance(keyword, str) and
+                (keyword.endswith('...') or '*' in keyword or '?' in keyword))
+
+    def _wildcardmatch(self, pattern):
+        """
+        Returns a list of indices of the cards matching the given wildcard
+        pattern.
+
+         * '*' matches 0 or more characters
+         * '?' matches a single character
+         * '...' matches 0 or more of any non-whitespace character
+        """
+
+        pattern = pattern.replace('*', r'.*').replace('?', r'.')
+        pattern = pattern.replace('...', r'\S*') + '$'
+        pattern_re = re.compile(pattern, re.I)
+
+        return [idx for idx, card in enumerate(self._cards)
+                if pattern_re.match(card.keyword)]
+
+    def _set_slice(self, key, value, target):
+        """
+        Used to implement Header.__setitem__ and CardAccessor.__setitem__.
+        """
+
+        if isinstance(key, slice) or self._haswildcard(key):
+            if isinstance(key, slice):
+                indices = range(*key.indices(len(target)))
+            else:
+                indices = self._wildcardmatch(key)
+
+            if isinstance(value, str) or not isiterable(value):
+                value = itertools.repeat(value, len(indices))
+
+            for idx, val in zip(indices, value):
+                target[idx] = val
+
+            return True
+
+        return False
+
+    def _splitcommentary(self, keyword, value):
+        """
+        Given a commentary keyword and value, returns a list of the one or more
+        cards needed to represent the full value.  This is primarily used to
+        create the multiple commentary cards needed to represent a long value
+        that won't fit into a single commentary card.
+        """
+
+        # The maximum value in each card can be the maximum card length minus
+        # the maximum key length (which can include spaces if they key length
+        # less than 8
+        maxlen = Card.length - KEYWORD_LENGTH
+        valuestr = str(value)
+
+        if len(valuestr) <= maxlen:
+            # The value can fit in a single card
+            cards = [Card(keyword, value)]
+        else:
+            # The value must be split across multiple consecutive commentary
+            # cards
+            idx = 0
+            cards = []
+            while idx < len(valuestr):
+                cards.append(Card(keyword, valuestr[idx:idx + maxlen]))
+                idx += maxlen
+        return cards
+
+    def _strip(self):
+        """
+        Strip cards specific to a certain kind of header.
+
+        Strip cards like ``SIMPLE``, ``BITPIX``, etc. so the rest of
+        the header can be used to reconstruct another kind of header.
+        """
+
+        # TODO: Previously this only deleted some cards specific to an HDU if
+        # _hdutype matched that type.  But it seemed simple enough to just
+        # delete all desired cards anyways, and just ignore the KeyErrors if
+        # they don't exist.
+        # However, it might be desirable to make this extendable somehow--have
+        # a way for HDU classes to specify some headers that are specific only
+        # to that type, and should be removed otherwise.
+
+        if 'NAXIS' in self:
+            naxis = self['NAXIS']
+        else:
+            naxis = 0
+
+        if 'TFIELDS' in self:
+            tfields = self['TFIELDS']
+        else:
+            tfields = 0
+
+        for idx in range(naxis):
+            try:
+                del self['NAXIS' + str(idx + 1)]
+            except KeyError:
+                pass
+
+        for name in ('TFORM', 'TSCAL', 'TZERO', 'TNULL', 'TTYPE',
+                     'TUNIT', 'TDISP', 'TDIM', 'THEAP', 'TBCOL'):
+            for idx in range(tfields):
+                try:
+                    del self[name + str(idx + 1)]
+                except KeyError:
+                    pass
+
+        for name in ('SIMPLE', 'XTENSION', 'BITPIX', 'NAXIS', 'EXTEND',
+                     'PCOUNT', 'GCOUNT', 'GROUPS', 'BSCALE', 'BZERO',
+                     'TFIELDS'):
+            try:
+                del self[name]
+            except KeyError:
+                pass
+
+    def _add_commentary(self, key, value, before=None, after=None):
+        """
+        Add a commentary card.
+
+        If ``before`` and ``after`` are `None`, add to the last occurrence
+        of cards of the same name (except blank card).  If there is no
+        card (or blank card), append at the end.
+        """
+
+        if before is not None or after is not None:
+            self._relativeinsert((key, value), before=before,
+                                 after=after)
+        else:
+            self[key] = value
+
+
+collections.abc.MutableSequence.register(Header)
+collections.abc.MutableMapping.register(Header)
+
+
+class _DelayedHeader:
+    """
+    Descriptor used to create the Header object from the header string that
+    was stored in HDU._header_str when parsing the file.
+    """
+
+    def __get__(self, obj, owner=None):
+        try:
+            return obj.__dict__['_header']
+        except KeyError:
+            if obj._header_str is not None:
+                hdr = Header.fromstring(obj._header_str)
+                obj._header_str = None
+            else:
+                raise AttributeError("'{}' object has no attribute '_header'"
+                                     .format(obj.__class__.__name__))
+
+            obj.__dict__['_header'] = hdr
+            return hdr
+
+    def __set__(self, obj, val):
+        obj.__dict__['_header'] = val
+
+    def __delete__(self, obj):
+        del obj.__dict__['_header']
+
+
+class _BasicHeaderCards:
+    """
+    This class allows to access cards with the _BasicHeader.cards attribute.
+
+    This is needed because during the HDU class detection, some HDUs uses
+    the .cards interface.  Cards cannot be modified here as the _BasicHeader
+    object will be deleted once the HDU object is created.
+
+    """
+
+    def __init__(self, header):
+        self.header = header
+
+    def __getitem__(self, key):
+        # .cards is a list of cards, so key here is an integer.
+        # get the keyword name from its index.
+        key = self.header._keys[key]
+        # then we get the card from the _BasicHeader._cards list, or parse it
+        # if needed.
+        try:
+            return self.header._cards[key]
+        except KeyError:
+            cardstr = self.header._raw_cards[key]
+            card = Card.fromstring(cardstr)
+            self.header._cards[key] = card
+            return card
+
+
+class _BasicHeader(collections.abc.Mapping):
+    """This class provides a fast header parsing, without all the additional
+    features of the Header class. Here only standard keywords are parsed, no
+    support for CONTINUE, HIERARCH, COMMENT, HISTORY, or rvkc.
+
+    The raw card images are stored and parsed only if needed. The idea is that
+    to create the HDU objects, only a small subset of standard cards is needed.
+    Once a card is parsed, which is deferred to the Card class, the Card object
+    is kept in a cache. This is useful because a small subset of cards is used
+    a lot in the HDU creation process (NAXIS, XTENSION, ...).
+
+    """
+
+    def __init__(self, cards):
+        # dict of (keywords, card images)
+        self._raw_cards = cards
+        self._keys = list(cards.keys())
+        # dict of (keyword, Card object) storing the parsed cards
+        self._cards = {}
+        # the _BasicHeaderCards object allows to access Card objects from
+        # keyword indices
+        self.cards = _BasicHeaderCards(self)
+
+        self._modified = False
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            key = self._keys[key]
+
+        try:
+            return self._cards[key].value
+        except KeyError:
+            # parse the Card and store it
+            cardstr = self._raw_cards[key]
+            self._cards[key] = card = Card.fromstring(cardstr)
+            return card.value
+
+    def __len__(self):
+        return len(self._raw_cards)
+
+    def __iter__(self):
+        return iter(self._raw_cards)
+
+    def index(self, keyword):
+        return self._keys.index(keyword)
+
+    @classmethod
+    def fromfile(cls, fileobj):
+        """The main method to parse a FITS header from a file. The parsing is
+        done with the parse_header function implemented in Cython."""
+
+        close_file = False
+        if isinstance(fileobj, str):
+            fileobj = open(fileobj, 'rb')
+            close_file = True
+
+        try:
+            header_str, cards = parse_header(fileobj)
+            _check_padding(header_str, BLOCK_SIZE, False)
+            return header_str, cls(cards)
+        finally:
+            if close_file:
+                fileobj.close()
+
+
+class _CardAccessor:
+    """
+    This is a generic class for wrapping a Header in such a way that you can
+    use the header's slice/filtering capabilities to return a subset of cards
+    and do something with them.
+
+    This is sort of the opposite notion of the old CardList class--whereas
+    Header used to use CardList to get lists of cards, this uses Header to get
+    lists of cards.
+    """
+
+    # TODO: Consider giving this dict/list methods like Header itself
+    def __init__(self, header):
+        self._header = header
+
+    def __repr__(self):
+        return '\n'.join(repr(c) for c in self._header._cards)
+
+    def __len__(self):
+        return len(self._header._cards)
+
+    def __iter__(self):
+        return iter(self._header._cards)
+
+    def __eq__(self, other):
+        # If the `other` item is a scalar we will still treat it as equal if
+        # this _CardAccessor only contains one item
+        if not isiterable(other) or isinstance(other, str):
+            if len(self) == 1:
+                other = [other]
+            else:
+                return False
+
+        for a, b in itertools.zip_longest(self, other):
+            if a != b:
+                return False
+        else:
+            return True
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __getitem__(self, item):
+        if isinstance(item, slice) or self._header._haswildcard(item):
+            return self.__class__(self._header[item])
+
+        idx = self._header._cardindex(item)
+        return self._header._cards[idx]
+
+    def _setslice(self, item, value):
+        """
+        Helper for implementing __setitem__ on _CardAccessor subclasses; slices
+        should always be handled in this same way.
+        """
+
+        if isinstance(item, slice) or self._header._haswildcard(item):
+            if isinstance(item, slice):
+                indices = range(*item.indices(len(self)))
+            else:
+                indices = self._header._wildcardmatch(item)
+            if isinstance(value, str) or not isiterable(value):
+                value = itertools.repeat(value, len(indices))
+            for idx, val in zip(indices, value):
+                self[idx] = val
+            return True
+        return False
+
+
+collections.abc.Mapping.register(_CardAccessor)
+collections.abc.Sequence.register(_CardAccessor)
+
+
+class _HeaderComments(_CardAccessor):
+    """
+    A class used internally by the Header class for the Header.comments
+    attribute access.
+
+    This object can be used to display all the keyword comments in the Header,
+    or look up the comments on specific keywords.  It allows all the same forms
+    of keyword lookup as the Header class itself, but returns comments instead
+    of values.
+    """
+
+    def __iter__(self):
+        for card in self._header._cards:
+            yield card.comment
+
+    def __repr__(self):
+        """Returns a simple list of all keywords and their comments."""
+
+        keyword_length = KEYWORD_LENGTH
+        for card in self._header._cards:
+            keyword_length = max(keyword_length, len(card.keyword))
+        return '\n'.join('{:>{len}}  {}'.format(c.keyword, c.comment,
+                                                len=keyword_length)
+                         for c in self._header._cards)
+
+    def __getitem__(self, item):
+        """
+        Slices and filter strings return a new _HeaderComments containing the
+        returned cards.  Otherwise the comment of a single card is returned.
+        """
+
+        item = super().__getitem__(item)
+        if isinstance(item, _HeaderComments):
+            # The item key was a slice
+            return item
+        return item.comment
+
+    def __setitem__(self, item, comment):
+        """
+        Set/update the comment on specified card or cards.
+
+        Slice/filter updates work similarly to how Header.__setitem__ works.
+        """
+
+        if self._header._set_slice(item, comment, self):
+            return
+
+        # In this case, key/index errors should be raised; don't update
+        # comments of nonexistent cards
+        idx = self._header._cardindex(item)
+        value = self._header[idx]
+        self._header[idx] = (value, comment)
+
+
+class _HeaderCommentaryCards(_CardAccessor):
+    """
+    This is used to return a list-like sequence over all the values in the
+    header for a given commentary keyword, such as HISTORY.
+    """
+
+    def __init__(self, header, keyword=''):
+        super().__init__(header)
+        self._keyword = keyword
+        self._count = self._header.count(self._keyword)
+        self._indices = slice(self._count).indices(self._count)
+
+    # __len__ and __iter__ need to be overridden from the base class due to the
+    # different approach this class has to take for slicing
+    def __len__(self):
+        return len(range(*self._indices))
+
+    def __iter__(self):
+        for idx in range(*self._indices):
+            yield self._header[(self._keyword, idx)]
+
+    def __repr__(self):
+        return '\n'.join(self)
+
+    def __getitem__(self, idx):
+        if isinstance(idx, slice):
+            n = self.__class__(self._header, self._keyword)
+            n._indices = idx.indices(self._count)
+            return n
+        elif not isinstance(idx, int):
+            raise ValueError('{} index must be an integer'.format(self._keyword))
+
+        idx = list(range(*self._indices))[idx]
+        return self._header[(self._keyword, idx)]
+
+    def __setitem__(self, item, value):
+        """
+        Set the value of a specified commentary card or cards.
+
+        Slice/filter updates work similarly to how Header.__setitem__ works.
+        """
+
+        if self._header._set_slice(item, value, self):
+            return
+
+        # In this case, key/index errors should be raised; don't update
+        # comments of nonexistent cards
+        self._header[(self._keyword, item)] = value
+
+
+def _block_size(sep):
+    """
+    Determine the size of a FITS header block if a non-blank separator is used
+    between cards.
+    """
+
+    return BLOCK_SIZE + (len(sep) * (BLOCK_SIZE // Card.length - 1))
+
+
+def _pad_length(stringlen):
+    """Bytes needed to pad the input stringlen to the next FITS block."""
+
+    return (BLOCK_SIZE - (stringlen % BLOCK_SIZE)) % BLOCK_SIZE
+
+
+def _check_padding(header_str, block_size, is_eof, check_block_size=True):
+    # Strip any zero-padding (see ticket #106)
+    if header_str and header_str[-1] == '\0':
+        if is_eof and header_str.strip('\0') == '':
+            # TODO: Pass this warning to validation framework
+            warnings.warn(
+                'Unexpected extra padding at the end of the file.  This '
+                'padding may not be preserved when saving changes.',
+                AstropyUserWarning)
+            raise EOFError()
+        else:
+            # Replace the illegal null bytes with spaces as required by
+            # the FITS standard, and issue a nasty warning
+            # TODO: Pass this warning to validation framework
+            warnings.warn(
+                'Header block contains null bytes instead of spaces for '
+                'padding, and is not FITS-compliant. Nulls may be '
+                'replaced with spaces upon writing.', AstropyUserWarning)
+            header_str.replace('\0', ' ')
+
+    if check_block_size and (len(header_str) % block_size) != 0:
+        # This error message ignores the length of the separator for
+        # now, but maybe it shouldn't?
+        actual_len = len(header_str) - block_size + BLOCK_SIZE
+        # TODO: Pass this error to validation framework
+        raise ValueError('Header size is not multiple of {0}: {1}'
+                         .format(BLOCK_SIZE, actual_len))

testbed/astropy__astropy/astropy/io/fits/scripts/fitscheck.py

@@ -0,0 +1,211 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+"""
+``fitscheck`` is a command line script based on astropy.io.fits for verifying
+and updating the CHECKSUM and DATASUM keywords of .fits files.  ``fitscheck``
+can also detect and often fix other FITS standards violations.  ``fitscheck``
+facilitates re-writing the non-standard checksums originally generated by
+astropy.io.fits with standard checksums which will interoperate with CFITSIO.
+
+``fitscheck`` will refuse to write new checksums if the checksum keywords are
+missing or their values are bad.  Use ``--force`` to write new checksums
+regardless of whether or not they currently exist or pass.  Use
+``--ignore-missing`` to tolerate missing checksum keywords without comment.
+
+Example uses of fitscheck:
+
+1. Add checksums::
+
+    $ fitscheck --write *.fits
+
+2. Write new checksums, even if existing checksums are bad or missing::
+
+    $ fitscheck --write --force *.fits
+
+3. Verify standard checksums and FITS compliance without changing the files::
+
+    $ fitscheck --compliance *.fits
+
+4. Only check and fix compliance problems,  ignoring checksums::
+
+    $ fitscheck --checksum none --compliance --write *.fits
+
+5. Verify standard interoperable checksums::
+
+    $ fitscheck *.fits
+
+6. Delete checksum keywords::
+
+    $ fitscheck --checksum remove --write *.fits
+
+"""
+
+
+import logging
+import optparse
+import sys
+import textwrap
+
+from astropy.tests.helper import catch_warnings
+from astropy.io import fits
+
+
+log = logging.getLogger('fitscheck')
+
+
+def handle_options(args):
+    if not len(args):
+        args = ['-h']
+
+    parser = optparse.OptionParser(usage=textwrap.dedent("""
+        fitscheck [options] <.fits files...>
+
+        .e.g. fitscheck example.fits
+
+        Verifies and optionally re-writes the CHECKSUM and DATASUM keywords
+        for a .fits file.
+        Optionally detects and fixes FITS standard compliance problems.
+        """.strip()))
+
+    parser.add_option(
+        '-k', '--checksum', dest='checksum_kind',
+        type='choice', choices=['standard', 'remove', 'none'],
+        help='Choose FITS checksum mode or none.  Defaults standard.',
+        default='standard', metavar='[standard | remove | none]')
+
+    parser.add_option(
+        '-w', '--write', dest='write_file',
+        help='Write out file checksums and/or FITS compliance fixes.',
+        default=False, action='store_true')
+
+    parser.add_option(
+        '-f', '--force', dest='force',
+        help='Do file update even if original checksum was bad.',
+        default=False, action='store_true')
+
+    parser.add_option(
+        '-c', '--compliance', dest='compliance',
+        help='Do FITS compliance checking; fix if possible.',
+        default=False, action='store_true')
+
+    parser.add_option(
+        '-i', '--ignore-missing', dest='ignore_missing',
+        help='Ignore missing checksums.',
+        default=False, action='store_true')
+
+    parser.add_option(
+        '-v', '--verbose', dest='verbose', help='Generate extra output.',
+        default=False, action='store_true')
+
+    global OPTIONS
+    OPTIONS, fits_files = parser.parse_args(args)
+
+    if OPTIONS.checksum_kind == 'none':
+        OPTIONS.checksum_kind = False
+    elif OPTIONS.checksum_kind == 'remove':
+        OPTIONS.write_file = True
+        OPTIONS.force = True
+
+    return fits_files
+
+
+def setup_logging():
+    if OPTIONS.verbose:
+        log.setLevel(logging.INFO)
+    else:
+        log.setLevel(logging.WARNING)
+
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter('%(message)s'))
+    log.addHandler(handler)
+
+
+def verify_checksums(filename):
+    """
+    Prints a message if any HDU in `filename` has a bad checksum or datasum.
+    """
+
+    with catch_warnings() as wlist:
+        with fits.open(filename, checksum=OPTIONS.checksum_kind) as hdulist:
+            for i, hdu in enumerate(hdulist):
+                # looping on HDUs is needed to read them and verify the
+                # checksums
+                if not OPTIONS.ignore_missing:
+                    if not hdu._checksum:
+                        log.warning('MISSING {!r} .. Checksum not found '
+                                    'in HDU #{}'.format(filename, i))
+                        return 1
+                    if not hdu._datasum:
+                        log.warning('MISSING {!r} .. Datasum not found '
+                                    'in HDU #{}'.format(filename, i))
+                        return 1
+
+    for w in wlist:
+        if str(w.message).startswith(('Checksum verification failed',
+                                      'Datasum verification failed')):
+            log.warning('BAD %r %s', filename, str(w.message))
+            return 1
+
+    log.info('OK {!r}'.format(filename))
+    return 0
+
+
+def verify_compliance(filename):
+    """Check for FITS standard compliance."""
+
+    with fits.open(filename) as hdulist:
+        try:
+            hdulist.verify('exception')
+        except fits.VerifyError as exc:
+            log.warning('NONCOMPLIANT %r .. %s',
+                        filename, str(exc).replace('\n', ' '))
+            return 1
+    return 0
+
+
+def update(filename):
+    """
+    Sets the ``CHECKSUM`` and ``DATASUM`` keywords for each HDU of `filename`.
+
+    Also updates fixes standards violations if possible and requested.
+    """
+
+    output_verify = 'silentfix' if OPTIONS.compliance else 'ignore'
+    with fits.open(filename, do_not_scale_image_data=True,
+                   checksum=OPTIONS.checksum_kind, mode='update') as hdulist:
+        hdulist.flush(output_verify=output_verify)
+
+
+def process_file(filename):
+    """
+    Handle a single .fits file,  returning the count of checksum and compliance
+    errors.
+    """
+
+    try:
+        checksum_errors = verify_checksums(filename)
+        if OPTIONS.compliance:
+            compliance_errors = verify_compliance(filename)
+        else:
+            compliance_errors = 0
+        if OPTIONS.write_file and checksum_errors == 0 or OPTIONS.force:
+            update(filename)
+        return checksum_errors + compliance_errors
+    except Exception as e:
+        log.error('EXCEPTION {!r} .. {}'.format(filename, e))
+        return 1
+
+
+def main(args=None):
+    """
+    Processes command line parameters into options and files,  then checks
+    or update FITS DATASUM and CHECKSUM keywords for the specified files.
+    """
+
+    errors = 0
+    fits_files = handle_options(args or sys.argv[1:])
+    setup_logging()
+    for filename in fits_files:
+        errors += process_file(filename)
+    if errors:
+        log.warning('{} errors'.format(errors))
+    return int(bool(errors))

testbed/astropy__astropy/astropy/io/fits/scripts/fitsheader.py

@@ -0,0 +1,452 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+"""
+``fitsheader`` is a command line script based on astropy.io.fits for printing
+the header(s) of one or more FITS file(s) to the standard output in a human-
+readable format.
+
+Example uses of fitsheader:
+
+1. Print the header of all the HDUs of a .fits file::
+
+    $ fitsheader filename.fits
+
+2. Print the header of the third and fifth HDU extension::
+
+    $ fitsheader --extension 3 --extension 5 filename.fits
+
+3. Print the header of a named extension, e.g. select the HDU containing
+   keywords EXTNAME='SCI' and EXTVER='2'::
+
+    $ fitsheader --extension "SCI,2" filename.fits
+
+4. Print only specific keywords::
+
+    $ fitsheader --keyword BITPIX --keyword NAXIS filename.fits
+
+5. Print keywords NAXIS, NAXIS1, NAXIS2, etc using a wildcard::
+
+    $ fitsheader --keyword NAXIS* filename.fits
+
+6. Dump the header keywords of all the files in the current directory into a
+   machine-readable csv file::
+
+    $ fitsheader --table ascii.csv *.fits > keywords.csv
+
+7. Specify hierarchical keywords with the dotted or spaced notation::
+
+    $ fitsheader --keyword ESO.INS.ID filename.fits
+    $ fitsheader --keyword "ESO INS ID" filename.fits
+
+8. Compare the headers of different fites files, following ESO's ``fitsort``
+   format::
+
+    $ fitsheader --fitsort --extension 0 --keyword ESO.INS.ID *.fits
+
+9. Same as above, sorting the output along a specified keyword::
+
+    $ fitsheader -f DATE-OBS -e 0 -k DATE-OBS -k ESO.INS.ID *.fits
+
+Note that compressed images (HDUs of type
+:class:`~astropy.io.fits.CompImageHDU`) really have two headers: a real
+BINTABLE header to describe the compressed data, and a fake IMAGE header
+representing the image that was compressed. Astropy returns the latter by
+default. You must supply the ``--compressed`` option if you require the real
+header that describes the compression.
+
+With Astropy installed, please run ``fitsheader --help`` to see the full usage
+documentation.
+"""
+
+import sys
+import argparse
+
+import numpy as np
+
+from astropy.io import fits
+from astropy import log
+
+
+class ExtensionNotFoundException(Exception):
+    """Raised if an HDU extension requested by the user does not exist."""
+    pass
+
+
+class HeaderFormatter:
+    """Class to format the header(s) of a FITS file for display by the
+    `fitsheader` tool; essentially a wrapper around a `HDUList` object.
+
+    Example usage:
+    fmt = HeaderFormatter('/path/to/file.fits')
+    print(fmt.parse(extensions=[0, 3], keywords=['NAXIS', 'BITPIX']))
+
+    Parameters
+    ----------
+    filename : str
+        Path to a single FITS file.
+    verbose : bool
+        Verbose flag, to show more information about missing extensions,
+        keywords, etc.
+
+    Raises
+    ------
+    OSError
+        If `filename` does not exist or cannot be read.
+    """
+
+    def __init__(self, filename, verbose=True):
+        self.filename = filename
+        self.verbose = verbose
+        self._hdulist = fits.open(filename)
+
+    def parse(self, extensions=None, keywords=None, compressed=False):
+        """Returns the FITS file header(s) in a readable format.
+
+        Parameters
+        ----------
+        extensions : list of int or str, optional
+            Format only specific HDU(s), identified by number or name.
+            The name can be composed of the "EXTNAME" or "EXTNAME,EXTVER"
+            keywords.
+
+        keywords : list of str, optional
+            Keywords for which the value(s) should be returned.
+            If not specified, then the entire header is returned.
+
+        compressed : boolean, optional
+            If True, shows the header describing the compression, rather than
+            the header obtained after decompression. (Affects FITS files
+            containing `CompImageHDU` extensions only.)
+
+        Returns
+        -------
+        formatted_header : str or astropy.table.Table
+            Traditional 80-char wide format in the case of `HeaderFormatter`;
+            an Astropy Table object in the case of `TableHeaderFormatter`.
+        """
+        # `hdukeys` will hold the keys of the HDUList items to display
+        if extensions is None:
+            hdukeys = range(len(self._hdulist))  # Display all by default
+        else:
+            hdukeys = []
+            for ext in extensions:
+                try:
+                    # HDU may be specified by number
+                    hdukeys.append(int(ext))
+                except ValueError:
+                    # The user can specify "EXTNAME" or "EXTNAME,EXTVER"
+                    parts = ext.split(',')
+                    if len(parts) > 1:
+                        extname = ','.join(parts[0:-1])
+                        extver = int(parts[-1])
+                        hdukeys.append((extname, extver))
+                    else:
+                        hdukeys.append(ext)
+
+        # Having established which HDUs the user wants, we now format these:
+        return self._parse_internal(hdukeys, keywords, compressed)
+
+    def _parse_internal(self, hdukeys, keywords, compressed):
+        """The meat of the formatting; in a separate method to allow overriding.
+        """
+        result = []
+        for idx, hdu in enumerate(hdukeys):
+            try:
+                cards = self._get_cards(hdu, keywords, compressed)
+            except ExtensionNotFoundException:
+                continue
+
+            if idx > 0:  # Separate HDUs by a blank line
+                result.append('\n')
+            result.append('# HDU {} in {}:\n'.format(hdu, self.filename))
+            for c in cards:
+                result.append('{}\n'.format(c))
+        return ''.join(result)
+
+    def _get_cards(self, hdukey, keywords, compressed):
+        """Returns a list of `astropy.io.fits.card.Card` objects.
+
+        This function will return the desired header cards, taking into
+        account the user's preference to see the compressed or uncompressed
+        version.
+
+        Parameters
+        ----------
+        hdukey : int or str
+            Key of a single HDU in the HDUList.
+
+        keywords : list of str, optional
+            Keywords for which the cards should be returned.
+
+        compressed : boolean, optional
+            If True, shows the header describing the compression.
+
+        Raises
+        ------
+        ExtensionNotFoundException
+            If the hdukey does not correspond to an extension.
+        """
+        # First we obtain the desired header
+        try:
+            if compressed:
+                # In the case of a compressed image, return the header before
+                # decompression (not the default behavior)
+                header = self._hdulist[hdukey]._header
+            else:
+                header = self._hdulist[hdukey].header
+        except (IndexError, KeyError):
+            message = '{0}: Extension {1} not found.'.format(self.filename,
+                                                             hdukey)
+            if self.verbose:
+                log.warning(message)
+            raise ExtensionNotFoundException(message)
+
+        if not keywords:  # return all cards
+            cards = header.cards
+        else:  # specific keywords are requested
+            cards = []
+            for kw in keywords:
+                try:
+                    crd = header.cards[kw]
+                    if isinstance(crd, fits.card.Card):  # Single card
+                        cards.append(crd)
+                    else:  # Allow for wildcard access
+                        cards.extend(crd)
+                except KeyError as e:  # Keyword does not exist
+                    if self.verbose:
+                        log.warning('{filename} (HDU {hdukey}): '
+                                    'Keyword {kw} not found.'.format(
+                                        filename=self.filename,
+                                        hdukey=hdukey,
+                                        kw=kw))
+        return cards
+
+    def close(self):
+        self._hdulist.close()
+
+
+class TableHeaderFormatter(HeaderFormatter):
+    """Class to convert the header(s) of a FITS file into a Table object.
+    The table returned by the `parse` method will contain four columns:
+    filename, hdu, keyword, and value.
+
+    Subclassed from HeaderFormatter, which contains the meat of the formatting.
+    """
+
+    def _parse_internal(self, hdukeys, keywords, compressed):
+        """Method called by the parse method in the parent class."""
+        tablerows = []
+        for hdu in hdukeys:
+            try:
+                for card in self._get_cards(hdu, keywords, compressed):
+                    tablerows.append({'filename': self.filename,
+                                      'hdu': hdu,
+                                      'keyword': card.keyword,
+                                      'value': str(card.value)})
+            except ExtensionNotFoundException:
+                pass
+
+        if tablerows:
+            from astropy import table
+            return table.Table(tablerows)
+        return None
+
+
+def print_headers_traditional(args):
+    """Prints FITS header(s) using the traditional 80-char format.
+
+    Parameters
+    ----------
+    args : argparse.Namespace
+        Arguments passed from the command-line as defined below.
+    """
+    for idx, filename in enumerate(args.filename):  # support wildcards
+        if idx > 0 and not args.keywords:
+            print()  # print a newline between different files
+
+        formatter = None
+        try:
+            formatter = HeaderFormatter(filename)
+            print(formatter.parse(args.extensions,
+                                  args.keywords,
+                                  args.compressed), end='')
+        except OSError as e:
+            log.error(str(e))
+        finally:
+            if formatter:
+                formatter.close()
+
+
+def print_headers_as_table(args):
+    """Prints FITS header(s) in a machine-readable table format.
+
+    Parameters
+    ----------
+    args : argparse.Namespace
+        Arguments passed from the command-line as defined below.
+    """
+    tables = []
+    # Create a Table object for each file
+    for filename in args.filename:  # Support wildcards
+        formatter = None
+        try:
+            formatter = TableHeaderFormatter(filename)
+            tbl = formatter.parse(args.extensions,
+                                  args.keywords,
+                                  args.compressed)
+            if tbl:
+                tables.append(tbl)
+        except OSError as e:
+            log.error(str(e))  # file not found or unreadable
+        finally:
+            if formatter:
+                formatter.close()
+
+    # Concatenate the tables
+    if len(tables) == 0:
+        return False
+    elif len(tables) == 1:
+        resulting_table = tables[0]
+    else:
+        from astropy import table
+        resulting_table = table.vstack(tables)
+    # Print the string representation of the concatenated table
+    resulting_table.write(sys.stdout, format=args.table)
+
+
+def print_headers_as_comparison(args):
+    """Prints FITS header(s) with keywords as columns.
+
+    This follows the dfits+fitsort format.
+
+    Parameters
+    ----------
+    args : argparse.Namespace
+        Arguments passed from the command-line as defined below.
+    """
+    from astropy import table
+    tables = []
+    # Create a Table object for each file
+    for filename in args.filename:  # Support wildcards
+        formatter = None
+        try:
+            formatter = TableHeaderFormatter(filename, verbose=False)
+            tbl = formatter.parse(args.extensions,
+                                  args.keywords,
+                                  args.compressed)
+            if tbl:
+                # Remove empty keywords
+                tbl = tbl[np.where(tbl['keyword'] != '')]
+            else:
+                tbl = table.Table([[filename]], names=('filename',))
+            tables.append(tbl)
+        except OSError as e:
+            log.error(str(e))  # file not found or unreadable
+        finally:
+            if formatter:
+                formatter.close()
+
+    # Concatenate the tables
+    if len(tables) == 0:
+        return False
+    elif len(tables) == 1:
+        resulting_table = tables[0]
+    else:
+        resulting_table = table.vstack(tables)
+
+    # If we obtained more than one hdu, merge hdu and keywords columns
+    hdus = resulting_table['hdu']
+    if np.ma.isMaskedArray(hdus):
+        hdus = hdus.compressed()
+    if len(np.unique(hdus)) > 1:
+        for tab in tables:
+            new_column = table.Column(
+                ['{}:{}'.format(row['hdu'], row['keyword']) for row in tab])
+            tab.add_column(new_column, name='hdu+keyword')
+        keyword_column_name = 'hdu+keyword'
+    else:
+        keyword_column_name = 'keyword'
+
+    # Check how many hdus we are processing
+    final_tables = []
+    for tab in tables:
+        final_table = [table.Column([tab['filename'][0]], name='filename')]
+        if 'value' in tab.colnames:
+            for row in tab:
+                if row['keyword'] in ('COMMENT', 'HISTORY'):
+                    continue
+                final_table.append(table.Column([row['value']],
+                                                name=row[keyword_column_name]))
+        final_tables.append(table.Table(final_table))
+    final_table = table.vstack(final_tables)
+    # Sort if requested
+    if args.fitsort is not True:  # then it must be a keyword, therefore sort
+        final_table.sort(args.fitsort)
+    # Reorganise to keyword by columns
+    final_table.pprint(max_lines=-1, max_width=-1)
+
+
+class KeywordAppendAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        keyword = values.replace('.', ' ')
+        if namespace.keywords is None:
+            namespace.keywords = []
+        if keyword not in namespace.keywords:
+            namespace.keywords.append(keyword)
+
+
+def main(args=None):
+    """This is the main function called by the `fitsheader` script."""
+
+    parser = argparse.ArgumentParser(
+        description=('Print the header(s) of a FITS file. '
+                     'Optional arguments allow the desired extension(s), '
+                     'keyword(s), and output format to be specified. '
+                     'Note that in the case of a compressed image, '
+                     'the decompressed header is shown by default.'))
+    parser.add_argument('-e', '--extension', metavar='HDU',
+                        action='append', dest='extensions',
+                        help='specify the extension by name or number; '
+                             'this argument can be repeated '
+                             'to select multiple extensions')
+    parser.add_argument('-k', '--keyword', metavar='KEYWORD',
+                        action=KeywordAppendAction, dest='keywords',
+                        help='specify a keyword; this argument can be '
+                             'repeated to select multiple keywords; '
+                             'also supports wildcards')
+    parser.add_argument('-t', '--table',
+                        nargs='?', default=False, metavar='FORMAT',
+                        help='print the header(s) in machine-readable table '
+                             'format; the default format is '
+                             '"ascii.fixed_width" (can be "ascii.csv", '
+                             '"ascii.html", "ascii.latex", "fits", etc)')
+    parser.add_argument('-f', '--fitsort', action='store_true',
+                        help='print the headers as a table with each unique '
+                             'keyword in a given column (fitsort format); '
+                             'if a SORT_KEYWORD is specified, the result will be '
+                             'sorted along that keyword')
+    parser.add_argument('-c', '--compressed', action='store_true',
+                        help='for compressed image data, '
+                             'show the true header which describes '
+                             'the compression rather than the data')
+    parser.add_argument('filename', nargs='+',
+                        help='path to one or more files; '
+                             'wildcards are supported')
+    args = parser.parse_args(args)
+
+    # If `--table` was used but no format specified,
+    # then use ascii.fixed_width by default
+    if args.table is None:
+        args.table = 'ascii.fixed_width'
+
+    # Now print the desired headers
+    try:
+        if args.table:
+            print_headers_as_table(args)
+        elif args.fitsort:
+            print_headers_as_comparison(args)
+        else:
+            print_headers_traditional(args)
+    except OSError as e:
+        # A 'Broken pipe' OSError may occur when stdout is closed prematurely,
+        # eg. when calling `fitsheader file.fits | head`. We let this pass.
+        pass

testbed/astropy__astropy/astropy/io/fits/setup_package.py

@@ -0,0 +1,68 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import os
+
+from distutils.core import Extension
+from glob import glob
+
+from astropy_helpers import setup_helpers
+from astropy_helpers.distutils_helpers import get_distutils_build_option
+
+
+def _get_compression_extension():
+    # 'numpy' will be replaced with the proper path to the numpy includes
+    cfg = setup_helpers.DistutilsExtensionArgs()
+    cfg['include_dirs'].append('numpy')
+    cfg['sources'].append(os.path.join(os.path.dirname(__file__), 'src',
+                                       'compressionmodule.c'))
+
+    if not setup_helpers.use_system_library('cfitsio'):
+        if setup_helpers.get_compiler_option() == 'msvc':
+            # These come from the CFITSIO vcc makefile, except the last
+            # which ensures on windows we do not include unistd.h (in regular
+            # compilation of cfitsio, an empty file would be generated)
+            cfg['extra_compile_args'].extend(
+                ['/D', '"WIN32"',
+                 '/D', '"_WINDOWS"',
+                 '/D', '"_MBCS"',
+                 '/D', '"_USRDLL"',
+                 '/D', '"_CRT_SECURE_NO_DEPRECATE"',
+                 '/D', '"FF_NO_UNISTD_H"'])
+        else:
+            cfg['extra_compile_args'].extend([
+                '-Wno-declaration-after-statement'
+            ])
+
+            if not get_distutils_build_option('debug'):
+                # these switches are to silence warnings from compiling CFITSIO
+                # For full silencing, some are added that only are used in
+                # later versions of gcc (versions approximate; see #6474)
+                cfg['extra_compile_args'].extend([
+                    '-Wno-strict-prototypes',
+                    '-Wno-unused',
+                    '-Wno-uninitialized',
+                    '-Wno-unused-result',  # gcc >~4.8
+                    '-Wno-misleading-indentation',  # gcc >~7.2
+                    '-Wno-format-overflow',  # gcc >~7.2
+                ])
+
+        cfitsio_lib_path = os.path.join('cextern', 'cfitsio', 'lib')
+        cfitsio_zlib_path = os.path.join('cextern', 'cfitsio', 'zlib')
+        cfitsio_files = glob(os.path.join(cfitsio_lib_path, '*.c'))
+        cfitsio_zlib_files = glob(os.path.join(cfitsio_zlib_path, '*.c'))
+        cfg['include_dirs'].append(cfitsio_lib_path)
+        cfg['include_dirs'].append(cfitsio_zlib_path)
+        cfg['sources'].extend(cfitsio_files)
+        cfg['sources'].extend(cfitsio_zlib_files)
+    else:
+        cfg.update(setup_helpers.pkg_config(['cfitsio'], ['cfitsio']))
+
+    return Extension('astropy.io.fits.compression', **cfg)
+
+
+def get_extensions():
+    return [_get_compression_extension()]
+
+
+def get_external_libraries():
+    return ['cfitsio']

testbed/astropy__astropy/astropy/io/fits/src/compressionmodule.c

@@ -0,0 +1,1323 @@
+/* "compression module */
+
+/*****************************************************************************/
+/*                                                                           */
+/* The compression software is a python module implemented in C that, when   */
+/* accessed through the astropy module, supports the storage of compressed   */
+/* images in FITS binary tables.  An n-dimensional image is divided into a   */
+/* rectangular grid of subimages or 'tiles'.  Each tile is then compressed   */
+/* as a continuous block of data, and the resulting compressed byte stream   */
+/* is stored in a row of a variable length column in a FITS binary table.    */
+/* The default tiling pattern treates each row of a 2-dimensional image      */
+/* (or higher dimensional cube) as a tile, such that each tile contains      */
+/* NAXIS1 pixels.                                                            */
+/*                                                                           */
+/* This module contains three functions that are callable from python.  The  */
+/* first is compress_hdu.  This function takes an                            */
+/* astropy.io.fits.CompImageHDU object containing the uncompressed image     */
+/* data and returns the compressed data for all tiles into the               */
+/* .compressed_data attribute of that HDU.                                   */
+/*                                                                           */
+/* The second function is decompress_hdu.  It takes an                       */
+/* astropy.io.fits.CompImageHDU object that already has compressed data in   */
+/* its .compressed_data attribute.  It returns the decompressed image data   */
+/* into the HDU's .data attribute.                                           */
+/*                                                                           */
+/* Copyright (C) 2013 Association of Universities for Research in Astronomy  */
+/* (AURA)                                                                    */
+/*                                                                           */
+/* Redistribution and use in source and binary forms, with or without        */
+/* modification, are permitted provided that the following conditions are    */
+/* met:                                                                      */
+/*                                                                           */
+/*    1. Redistributions of source code must retain the above copyright      */
+/*      notice, this list of conditions and the following disclaimer.        */
+/*                                                                           */
+/*    2. Redistributions in binary form must reproduce the above             */
+/*      copyright notice, this list of conditions and the following          */
+/*      disclaimer in the documentation and/or other materials provided      */
+/*      with the distribution.                                               */
+/*                                                                           */
+/*    3. The name of AURA and its representatives may not be used to         */
+/*      endorse or promote products derived from this software without       */
+/*      specific prior written permission.                                   */
+/*                                                                           */
+/* THIS SOFTWARE IS PROVIDED BY AURA ``AS IS'' AND ANY EXPRESS OR IMPLIED    */
+/* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF      */
+/* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE                  */
+/* DISCLAIMED. IN NO EVENT SHALL AURA BE LIABLE FOR ANY DIRECT, INDIRECT,    */
+/* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,      */
+/* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS     */
+/* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND    */
+/* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR     */
+/* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE    */
+/* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH          */
+/* DAMAGE.                                                                   */
+/*                                                                           */
+/* Some of the source code used by this module was copied and modified from  */
+/* the FITSIO software that was written by William Pence at the High Energy  */
+/* Astrophysic Science Archive Research Center (HEASARC) at the NASA Goddard */
+/* Space Flight Center.  That software contained the following copyright and */
+/* warranty notices:                                                         */
+/*                                                                           */
+/* Copyright (Unpublished--all rights reserved under the copyright laws of   */
+/* the United States), U.S. Government as represented by the Administrator   */
+/* of the National Aeronautics and Space Administration.  No copyright is    */
+/* claimed in the United States under Title 17, U.S. Code.                   */
+/*                                                                           */
+/* Permission to freely use, copy, modify, and distribute this software      */
+/* and its documentation without fee is hereby granted, provided that this   */
+/* copyright notice and disclaimer of warranty appears in all copies.        */
+/*                                                                           */
+/* DISCLAIMER:                                                               */
+/*                                                                           */
+/* THE SOFTWARE IS PROVIDED 'AS IS' WITHOUT ANY WARRANTY OF ANY KIND,        */
+/* EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO,   */
+/* ANY WARRANTY THAT THE SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY        */
+/* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR           */
+/* PURPOSE, AND FREEDOM FROM INFRINGEMENT, AND ANY WARRANTY THAT THE         */
+/* DOCUMENTATION WILL CONFORM TO THE SOFTWARE, OR ANY WARRANTY THAT THE      */
+/* SOFTWARE WILL BE ERROR FREE.  IN NO EVENT SHALL NASA BE LIABLE FOR ANY    */
+/* DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL OR      */
+/* CONSEQUENTIAL DAMAGES, ARISING OUT OF, RESULTING FROM, OR IN ANY WAY      */
+/* CONNECTED WITH THIS SOFTWARE, WHETHER OR NOT BASED UPON WARRANTY,         */
+/* CONTRACT, TORT , OR OTHERWISE, WHETHER OR NOT INJURY WAS SUSTAINED BY     */
+/* PERSONS OR PROPERTY OR OTHERWISE, AND WHETHER OR NOT LOSS WAS SUSTAINED   */
+/* FROM, OR AROSE OUT OF THE RESULTS OF, OR USE OF, THE SOFTWARE OR          */
+/* SERVICES PROVIDED HEREUNDER."                                             */
+/*                                                                           */
+/*****************************************************************************/
+
+/* Include the Python C API */
+
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+#include <string.h>
+
+#include <Python.h>
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include <numpy/arrayobject.h>
+#include <fitsio2.h>
+#include "compressionmodule.h"
+
+
+/* These defaults mirror the defaults in astropy.io.fits.hdu.compressed */
+#define DEFAULT_COMPRESSION_TYPE "RICE_1"
+#define DEFAULT_QUANTIZE_LEVEL 16.0
+#define DEFAULT_HCOMP_SCALE 0
+#define DEFAULT_HCOMP_SMOOTH 0
+#define DEFAULT_BLOCK_SIZE 32
+#define DEFAULT_BYTE_PIX 4
+
+/* Flags to pass to get_header_* functions to control error messages. */
+typedef enum {
+    HDR_NOFLAG = 0,
+    HDR_FAIL_KEY_MISSING = 1 << 0,
+    HDR_FAIL_VAL_NEGATIVE = 1 << 1,
+} HeaderGetFlags;
+
+
+/* Report any error based on the status returned from cfitsio. */
+void process_status_err(int status)
+{
+   PyObject* except_type;
+   char      err_msg[81];
+   char      def_err_msg[81];
+
+   err_msg[0] = '\0';
+   def_err_msg[0] = '\0';
+
+   switch (status) {
+      case MEMORY_ALLOCATION:
+         except_type = PyExc_MemoryError;
+         break;
+      case OVERFLOW_ERR:
+         except_type = PyExc_OverflowError;
+         break;
+      case BAD_COL_NUM:
+         strcpy(def_err_msg, "bad column number");
+         except_type = PyExc_ValueError;
+         break;
+      case BAD_PIX_NUM:
+         strcpy(def_err_msg, "bad pixel number");
+         except_type = PyExc_ValueError;
+         break;
+      case NEG_AXIS:
+         strcpy(def_err_msg, "negative axis number");
+         except_type = PyExc_ValueError;
+         break;
+      case BAD_DATATYPE:
+         strcpy(def_err_msg, "bad data type");
+         except_type = PyExc_TypeError;
+         break;
+      case NO_COMPRESSED_TILE:
+         strcpy(def_err_msg, "no compressed or uncompressed data for tile.");
+         except_type = PyExc_ValueError;
+         break;
+      default:
+         except_type = PyExc_RuntimeError;
+         break;
+   }
+
+   if (fits_read_errmsg(err_msg)) {
+      PyErr_SetString(except_type, err_msg);
+   } else if (*def_err_msg) {
+      PyErr_SetString(except_type, def_err_msg);
+   } else {
+      PyErr_Format(except_type, "unknown error %i.", status);
+   }
+}
+
+
+void bitpix_to_datatypes(int bitpix, int* datatype, int* npdatatype) {
+    /* Given a FITS BITPIX value, returns the appropriate CFITSIO type code and
+       Numpy type code for that BITPIX into datatype and npdatatype
+       respectively.
+     */
+    switch (bitpix) {
+        case BYTE_IMG:
+            *datatype = TBYTE;
+            *npdatatype = NPY_INT8;
+            break;
+        case SHORT_IMG:
+            *datatype = TSHORT;
+            *npdatatype = NPY_INT16;
+            break;
+        case LONG_IMG:
+            *datatype = TINT;
+            *npdatatype = NPY_INT32;
+            break;
+        case LONGLONG_IMG:
+            *datatype = TLONGLONG;
+            *npdatatype = NPY_LONGLONG;
+            break;
+        case FLOAT_IMG:
+            *datatype = TFLOAT;
+            *npdatatype = NPY_FLOAT;
+            break;
+        case DOUBLE_IMG:
+            *datatype = TDOUBLE;
+            *npdatatype = NPY_DOUBLE;
+            break;
+        default:
+            PyErr_Format(PyExc_ValueError, "Invalid value for BITPIX: %d",
+                         bitpix);
+            break;
+   }
+
+   return;
+}
+
+
+
+int compress_type_from_string(char* zcmptype) {
+    if (0 == strcmp(zcmptype, "RICE_1")) {
+        return RICE_1;
+    } else if (0 == strcmp(zcmptype, "GZIP_1")) {
+        return GZIP_1;
+    } else if (0 == strcmp(zcmptype, "GZIP_2")) {
+        return GZIP_2;
+    } else if (0 == strcmp(zcmptype, "PLIO_1")) {
+        return PLIO_1;
+    } else if (0 == strcmp(zcmptype, "HCOMPRESS_1")) {
+        return HCOMPRESS_1;
+    }
+#ifdef CFITSIO_SUPPORTS_SUBTRACTIVE_DITHER_2
+    /* CFITSIO adds a compression type alias for RICE_1 compression
+       as a flag for using subtractive_dither_2 */
+    else if (0 == strcmp(zcmptype, "RICE_ONE")) {
+        return RICE_1;
+    }
+#endif
+    else {
+        PyErr_Format(PyExc_ValueError, "Unrecognized compression type: %s",
+                     zcmptype);
+        return -1;
+    }
+}
+
+
+PyObject *
+get_header_value(PyObject* header, const char* key, HeaderGetFlags flags) {
+    PyObject* hdrkey;
+    PyObject* hdrval;
+    hdrkey = PyUnicode_FromString(key);
+    if (hdrkey == NULL) {
+        return NULL;
+    }
+    hdrval = PyObject_GetItem(header, hdrkey);
+    Py_DECREF(hdrkey);
+    if ((flags & HDR_FAIL_KEY_MISSING) == 0) {
+        /* Normally we have a default so we want to ignore the exception in
+           any case. But if the flag was given this step must be skipped. */
+        PyErr_Clear();
+    }
+    return hdrval;
+}
+
+
+// TODO: It might be possible to simplify these further by making the
+// conversion function (eg. PyString_AsString) an argument to a macro or
+// something, but I'm not sure yet how easy it is to generalize the error
+// handling
+/* The get_header_* functions resemble "Header.get" where "def" is the default
+   value, "keyword" is a string representing the header-key and the result is
+   stored in "val".
+   The function returns 0 on success, 1 if the header didn't have the keyword
+   and the default was applied and -1 (with an exception set) if an Exception
+   happened (like a MemoryError or Overflow).
+*/
+#define GET_HEADER_SUCCESS 0
+#define GET_HEADER_DEFAULT_USED 1
+#define GET_HEADER_FAILED -1
+int get_header_string(PyObject* header, const char* keyword, char* val,
+                      const char* def, HeaderGetFlags flags) {
+    /* nonnegative doesn't make sense for strings*/
+    assert(!(flags & HDR_FAIL_VAL_NEGATIVE));
+    PyObject* keyval = get_header_value(header, keyword, flags);
+
+    if (keyval == NULL) {
+        strncpy(val, def, 72);
+        return PyErr_Occurred() ? GET_HEADER_FAILED : GET_HEADER_DEFAULT_USED;
+    }
+    PyObject* tmp = PyUnicode_AsLatin1String(keyval);
+    // FITS header values should always be ASCII, but Latin1 is on the
+    // safe side
+    Py_DECREF(keyval);
+    if (tmp == NULL) {
+        /* could always fail to allocate the memory or such like. */
+        return GET_HEADER_FAILED;
+    }
+    strncpy(val, PyBytes_AsString(tmp), 72);
+    Py_DECREF(tmp);
+    return GET_HEADER_SUCCESS;
+}
+
+
+int get_header_long(PyObject* header, const char* keyword, long* val, long def,
+                    HeaderGetFlags flags) {
+    PyObject* keyval = get_header_value(header, keyword, flags);
+
+    if (keyval == NULL) {
+        *val = def;
+        return PyErr_Occurred() ? GET_HEADER_FAILED : GET_HEADER_DEFAULT_USED;
+    }
+    long tmp = PyLong_AsLong(keyval);
+    Py_DECREF(keyval);
+    if (PyErr_Occurred()) {
+        return GET_HEADER_FAILED;
+    }
+    if ((flags & HDR_FAIL_VAL_NEGATIVE) && (tmp < 0)) {
+        PyErr_Format(PyExc_ValueError, "%s should not be negative.", keyword);
+        return GET_HEADER_FAILED;
+    }
+    *val = tmp;
+    return GET_HEADER_SUCCESS;
+}
+
+
+int get_header_int(PyObject* header, const char* keyword, int* val, int def,
+                   HeaderGetFlags flags) {
+    long tmp;
+    int ret = get_header_long(header, keyword, &tmp, def, flags);
+    if (ret == GET_HEADER_SUCCESS) {
+        if (tmp >= INT_MIN && tmp <= INT_MAX) {
+            *val = (int) tmp;
+        } else {
+            PyErr_Format(PyExc_OverflowError, "Cannot convert %ld to C 'int'", tmp);
+            ret = GET_HEADER_FAILED;
+        }
+    }
+    return ret;
+}
+
+
+int get_header_double(PyObject* header, const char* keyword, double* val,
+                      double def, HeaderGetFlags flags) {
+    /* nonnegative isn't currently used for doubles/floats. But if needed one
+       could simply remove the assert again and implement the negative check. */
+    assert(!(flags & HDR_FAIL_VAL_NEGATIVE));
+    PyObject* keyval = get_header_value(header, keyword, flags);
+
+    if (keyval == NULL) {
+        *val = def;
+        return PyErr_Occurred() ? GET_HEADER_FAILED : GET_HEADER_DEFAULT_USED;
+    }
+    double tmp = PyFloat_AsDouble(keyval);
+    Py_DECREF(keyval);
+    if (PyErr_Occurred()) {
+        return GET_HEADER_FAILED;
+    }
+    *val = tmp;
+    return GET_HEADER_SUCCESS;
+}
+
+
+int get_header_float(PyObject* header, const char* keyword, float* val,
+                     float def, HeaderGetFlags flags) {
+    double tmp;
+    int ret = get_header_double(header, keyword, &tmp, def, flags);
+    if (ret == GET_HEADER_SUCCESS) {
+        if (tmp == 0.0 || (fabs(tmp) >= FLT_MIN && fabs(tmp) <= FLT_MAX)) {
+            *val = (float) tmp;
+        } else {
+            PyErr_SetString(PyExc_OverflowError,
+                            "Cannot convert 'double' to 'float'");
+            ret = GET_HEADER_FAILED;
+        }
+    }
+    return ret;
+}
+
+
+int get_header_longlong(PyObject* header, const char* keyword, long long* val,
+                        long long def, HeaderGetFlags flags) {
+    PyObject* keyval = get_header_value(header, keyword, flags);
+
+    if (keyval == NULL) {
+        *val = def;
+        return PyErr_Occurred() ? GET_HEADER_FAILED : GET_HEADER_DEFAULT_USED;
+    }
+    long long tmp = PyLong_AsLongLong(keyval);
+    Py_DECREF(keyval);
+    if (PyErr_Occurred()) {
+        return GET_HEADER_FAILED;
+    }
+    if ((flags & HDR_FAIL_VAL_NEGATIVE) && (tmp < 0)) {
+        PyErr_Format(PyExc_ValueError, "%s should not be negative.", keyword);
+        return GET_HEADER_FAILED;
+    }
+    *val = tmp;
+    return GET_HEADER_SUCCESS;
+}
+
+
+void tcolumns_from_header(fitsfile* fileptr, PyObject* header,
+                          tcolumn** columns) {
+    // Creates the array of tcolumn structures from the table column keywords
+    // read from the astropy.io.fits.Header object; caller is responsible for
+    // freeing the memory allocated for this array
+
+    tcolumn* column;
+    char tkw[9];
+
+    int tfields;
+    char ttype[72];
+    char tform[72];
+    int dtcode;
+    long trepeat;
+    long twidth;
+    long long totalwidth;
+    int status = 0;
+    int idx;
+
+    if (get_header_int(header, "TFIELDS", &tfields, 0, HDR_FAIL_VAL_NEGATIVE) == GET_HEADER_FAILED) {
+        return;
+    }
+    /* To avoid issues in the loop we need to limit the number of TFIELDs to
+       999. Otherwise we would exceed the maximum length of the keyword name of
+       8. This could lead to multiple accesses of the same header keyword with
+       snprintf because we limit it to 8 characters + null-termination. */
+    if (tfields > 999) {
+        PyErr_SetString(PyExc_ValueError, "The TFIELDS value exceeds 999.");
+        return;
+    }
+
+    // This used to use PyMem_New, but don't do that; CFITSIO will later
+    // free() this object when the file is closed, so just use malloc here
+    // *columns = column = PyMem_New(tcolumn, (size_t) tfields);
+    *columns = column = calloc((size_t) tfields, sizeof(tcolumn));
+    if (column == NULL) {
+        PyErr_SetString(PyExc_MemoryError,
+                        "Couldn't allocate memory for columns.");
+        return;
+    }
+
+
+    for (idx = 1; idx <= tfields; idx++, column++) {
+        /* set some invalid defaults */
+        column->ttype[0] = '\0';
+        column->tbcol = 0;
+        column->tdatatype = -9999; /* this default used by cfitsio */
+        column->trepeat = 1;
+        column->strnull[0] = '\0';
+        column->tform[0] = '\0';
+        column->twidth = 0;
+
+        snprintf(tkw, 9, "TTYPE%u", idx);
+        if (get_header_string(header, tkw, ttype, "", HDR_NOFLAG) == GET_HEADER_FAILED) {
+            return;
+        }
+        strncpy(column->ttype, ttype, 69);
+        column->ttype[69] = '\0';
+
+        snprintf(tkw, 9, "TFORM%u", idx);
+        if (get_header_string(header, tkw, tform, "", HDR_NOFLAG) == GET_HEADER_FAILED) {
+            return;
+        }
+        strncpy(column->tform, tform, 9);
+        column->tform[9] = '\0';
+        fits_binary_tform(tform, &dtcode, &trepeat, &twidth, &status);
+        if (status != 0) {
+            process_status_err(status);
+            return;
+        }
+
+        column->tdatatype = dtcode;
+        column->trepeat = trepeat;
+        column->twidth = twidth;
+
+        snprintf(tkw, 9, "TSCAL%u", idx);
+        if (get_header_double(header, tkw, &(column->tscale), 1.0, HDR_NOFLAG) == GET_HEADER_FAILED) {
+            return;
+        }
+
+        snprintf(tkw, 9, "TZERO%u", idx);
+        if (get_header_double(header, tkw, &(column->tzero), 0.0, HDR_NOFLAG) == GET_HEADER_FAILED) {
+            return;
+        }
+
+        snprintf(tkw, 9, "TNULL%u", idx);
+        if (get_header_longlong(header, tkw, &(column->tnull), NULL_UNDEFINED, HDR_NOFLAG) == GET_HEADER_FAILED) {
+            return;
+        }
+    }
+
+    fileptr->Fptr->tableptr = *columns;
+    fileptr->Fptr->tfield = tfields;
+
+    // This routine from CFITSIO calculates the byte offset of each column
+    // and stores it in the column->tbcol field
+    ffgtbc(fileptr, &totalwidth, &status);
+    if (status != 0) {
+        process_status_err(status);
+    }
+
+    return;
+}
+
+
+
+void configure_compression(fitsfile* fileptr, PyObject* header) {
+    /* Configure the compression-related elements in the fitsfile struct
+       using values in the FITS header. */
+
+    FITSfile* Fptr;
+
+    int tfields;
+    tcolumn* columns;
+
+    char keyword[9];
+    char zname[72];
+    int znaxis;
+    char tmp[72];
+    float version;
+
+    int idx;
+
+    Fptr = fileptr->Fptr;
+    tfields = Fptr->tfield;
+    columns = Fptr->tableptr;
+
+    int tmp_retval;
+
+    // Get the ZBITPIX header value; if this is missing we're in trouble
+    if (get_header_int(header, "ZBITPIX", &(Fptr->zbitpix), 0, HDR_FAIL_KEY_MISSING) != GET_HEADER_SUCCESS) {
+        return;
+    }
+
+    // By default assume there is no ZBLANK column and check for ZBLANK or
+    // BLANK in the header
+    Fptr->cn_zblank = Fptr->cn_zzero = Fptr->cn_zscale = -1;
+    Fptr->cn_uncompressed = 0;
+#ifdef CFITSIO_SUPPORTS_GZIPDATA
+    Fptr->cn_gzip_data = 0;
+#endif
+
+    // Check for a ZBLANK, ZZERO, ZSCALE, and
+    // UNCOMPRESSED_DATA/GZIP_COMPRESSED_DATA columns in the compressed data
+    // table
+    for (idx = 0; idx < tfields; idx++) {
+        if (0 == strncmp(columns[idx].ttype, "UNCOMPRESSED_DATA", 18)) {
+            Fptr->cn_uncompressed = idx + 1;
+#ifdef CFITSIO_SUPPORTS_GZIPDATA
+        } else if (0 == strncmp(columns[idx].ttype,
+                                "GZIP_COMPRESSED_DATA", 21)) {
+            Fptr->cn_gzip_data = idx + 1;
+#endif
+        } else if (0 == strncmp(columns[idx].ttype, "ZSCALE", 7)) {
+            Fptr->cn_zscale = idx + 1;
+        } else if (0 == strncmp(columns[idx].ttype, "ZZERO", 6)) {
+            Fptr->cn_zzero = idx + 1;
+        } else if (0 == strncmp(columns[idx].ttype, "ZBLANK", 7)) {
+            Fptr->cn_zblank = idx + 1;
+        }
+    }
+
+    Fptr->zblank = 0;
+    if (Fptr->cn_zblank < 1) {
+        // No ZBLANK column--check the ZBLANK and BLANK heard keywords
+        switch (get_header_int(header, "ZBLANK", &(Fptr->zblank), 0, HDR_NOFLAG)) {
+          case GET_HEADER_FAILED:
+            return;
+          case GET_HEADER_DEFAULT_USED:
+            // ZBLANK keyword not found
+            if (get_header_int(header, "BLANK", &(Fptr->zblank), 0, HDR_NOFLAG) == GET_HEADER_FAILED) {
+              return;
+            }
+            break;
+          default:
+            break;
+        }
+    }
+
+    Fptr->zscale = 1.0;
+    if (Fptr->cn_zscale < 1) {
+        switch (get_header_double(header, "ZSCALE", &(Fptr->zscale), 1.0, HDR_NOFLAG)) {
+          case GET_HEADER_FAILED:
+            return;
+          case GET_HEADER_DEFAULT_USED:
+            Fptr->cn_zscale = 0;
+            break;
+          default:
+            break;
+        }
+    }
+    Fptr->cn_bscale = Fptr->zscale;
+
+    Fptr->zzero = 0.0;
+    if (Fptr->cn_zzero < 1) {
+        switch (get_header_double(header, "ZZERO", &(Fptr->zzero), 0.0, HDR_NOFLAG)) {
+          case GET_HEADER_FAILED:
+            return;
+          case GET_HEADER_DEFAULT_USED:
+            Fptr->cn_zzero = 0;
+            break;
+          default:
+            break;
+        }
+    }
+    Fptr->cn_bzero = Fptr->zzero;
+
+    if (get_header_string(header, "ZCMPTYPE", tmp, DEFAULT_COMPRESSION_TYPE, HDR_NOFLAG) == GET_HEADER_FAILED) {
+        return;
+    }
+    strncpy(Fptr->zcmptype, tmp, 11);
+    Fptr->zcmptype[strlen(tmp)] = '\0';
+
+    Fptr->compress_type = compress_type_from_string(Fptr->zcmptype);
+    if (PyErr_Occurred()) {
+        return;
+    }
+
+    if (get_header_int(header, "ZNAXIS", &znaxis, 0, HDR_NOFLAG) == GET_HEADER_FAILED) {
+        return;
+    }
+    Fptr->zndim = znaxis;
+
+    if (znaxis > MAX_COMPRESS_DIM) {
+        // The CFITSIO compression code currently only supports up to 6
+        // dimensions by default.
+        znaxis = MAX_COMPRESS_DIM;
+    }
+
+    Fptr->tilerow = NULL;
+    Fptr->maxtilelen = 1;
+    for (idx = 1; idx <= znaxis; idx++) {
+        snprintf(keyword, 9, "ZNAXIS%u", idx);
+        if (get_header_long(header, keyword, Fptr->znaxis + idx - 1, 0, HDR_NOFLAG) == GET_HEADER_FAILED) {
+            return;
+        }
+        snprintf(keyword, 9, "ZTILE%u", idx);
+        if (get_header_long(header, keyword, Fptr->tilesize + idx - 1, 0, HDR_NOFLAG) == GET_HEADER_FAILED) {
+            return;
+        }
+        Fptr->maxtilelen *= Fptr->tilesize[idx - 1];
+    }
+
+    // Set some more default compression options
+    Fptr->rice_blocksize = DEFAULT_BLOCK_SIZE;
+    Fptr->rice_bytepix = DEFAULT_BYTE_PIX;
+    Fptr->quantize_level = DEFAULT_QUANTIZE_LEVEL;
+    Fptr->hcomp_smooth = DEFAULT_HCOMP_SMOOTH;
+    Fptr->hcomp_scale = DEFAULT_HCOMP_SCALE;
+
+    // Now process the ZVALn keywords
+    idx = 1;
+    while (1) {
+        snprintf(keyword, 9, "ZNAME%u", idx);
+        // Assumes there are no gaps in the ZNAMEn keywords; this same
+        // assumption was made in the Python code.  This could be done slightly
+        // more flexibly by using a wildcard slice of the header
+        tmp_retval = get_header_string(header, keyword, zname, "", HDR_NOFLAG);
+        if (tmp_retval == GET_HEADER_FAILED) {
+            return;
+        } else if (tmp_retval == 1) {
+            break;
+        }
+
+        snprintf(keyword, 9, "ZVAL%u", idx);
+        if (Fptr->compress_type == RICE_1) {
+            if (0 == strcmp(zname, "BLOCKSIZE")) {
+                if (get_header_int(header, keyword, &(Fptr->rice_blocksize),
+                                   DEFAULT_BLOCK_SIZE, HDR_NOFLAG) == GET_HEADER_FAILED) {
+                    return;
+                }
+            } else if (0 == strcmp(zname, "BYTEPIX")) {
+                if (get_header_int(header, keyword, &(Fptr->rice_bytepix),
+                                   DEFAULT_BYTE_PIX, HDR_NOFLAG) == GET_HEADER_FAILED) {
+                    return;
+                }
+            }
+        } else if (Fptr->compress_type == HCOMPRESS_1) {
+            if (0 == strcmp(zname, "SMOOTH")) {
+                if (get_header_int(header, keyword, &(Fptr->hcomp_smooth),
+                                   DEFAULT_HCOMP_SMOOTH, HDR_NOFLAG) == GET_HEADER_FAILED) {
+                    return;
+                }
+            } else if (0 == strcmp(zname, "SCALE")) {
+                if (get_header_float(header, keyword, &(Fptr->hcomp_scale),
+                                     DEFAULT_HCOMP_SCALE, HDR_NOFLAG) == GET_HEADER_FAILED) {
+                    return;
+                }
+            }
+        }
+        if (Fptr->zbitpix < 0 && 0 == strcmp(zname, "NOISEBIT")) {
+            if (get_header_float(header, keyword, &(Fptr->quantize_level),
+                                 DEFAULT_QUANTIZE_LEVEL, HDR_NOFLAG) == GET_HEADER_FAILED) {
+                return;
+            }
+            if (Fptr->quantize_level == 0.0) {
+                /* NOISEBIT == 0 is equivalent to no quantize */
+                Fptr->quantize_level = NO_QUANTIZE;
+            }
+        }
+
+        idx++;
+    }
+
+    /* The ZQUANTIZ keyword determines the quantization algorithm; NO_QUANTIZE
+       implies lossless compression */
+    tmp_retval = get_header_string(header, "ZQUANTIZ", tmp, "", HDR_NOFLAG);
+    if (tmp_retval == GET_HEADER_FAILED) {
+        return;
+    } else if (tmp_retval == GET_HEADER_SUCCESS) {
+        /* Ugh; the fact that cfitsio defines its version as a float makes
+           preprocessor comparison impossible */
+        fits_get_version(&version);
+        if ((version >= CFITSIO_LOSSLESS_COMP_SUPPORTED_VERS) &&
+                (0 == strcmp(tmp, "NONE"))) {
+            Fptr->quantize_level = NO_QUANTIZE;
+        } else if (0 == strcmp(tmp, "SUBTRACTIVE_DITHER_1")) {
+#ifdef CFITSIO_SUPPORTS_SUBTRACTIVE_DITHER_2
+            // Added in CFITSIO 3.35, this also changed the name of the
+            // quantize_dither struct member to quantize_method
+            Fptr->quantize_method = SUBTRACTIVE_DITHER_1;
+        } else if (0 == strcmp(tmp, "SUBTRACTIVE_DITHER_2")) {
+            Fptr->quantize_method = SUBTRACTIVE_DITHER_2;
+        } else {
+            Fptr->quantize_method = NO_DITHER;
+        }
+    } else {
+        Fptr->quantize_method = NO_DITHER;
+    }
+
+    if (Fptr->quantize_method != NO_DITHER) {
+        switch (get_header_int(header, "ZDITHER0", &(Fptr->dither_seed), 0, HDR_NOFLAG)) {
+          case GET_HEADER_FAILED:
+            return;
+          case GET_HEADER_DEFAULT_USED: // ZDITHER0 keyword not found
+            Fptr->dither_seed = 0;
+            Fptr->request_dither_seed = 0;
+            break;
+          default:
+            break;
+        }
+    }
+#else
+            Fptr->quantize_dither = SUBTRACTIVE_DITHER_1;
+        } else {
+            Fptr->quantize_dither = NO_DITHER;
+        }
+    } else {
+        Fptr->quantize_dither = NO_DITHER;
+    }
+
+    if (Fptr->quantize_dither != NO_DITHER) {
+        switch (get_header_int(header, "ZDITHER0", &(Fptr->dither_offset), 0, HDR_NOFLAG)) {
+          case GET_HEADER_FAILED:
+            return;
+          case GET_HEADER_DEFAULT_USED: // ZDITHER0 keyword no found
+            /* TODO: Find out if that's actually working and not invalid... */
+            Fptr->dither_offset = 0;
+            Fptr->request_dither_offset = 0;
+            break;
+          default:
+            break;
+        }
+    }
+#endif
+
+    Fptr->compressimg = 1;
+    Fptr->maxelem = imcomp_calc_max_elem(Fptr->compress_type,
+                                         Fptr->maxtilelen,
+                                         Fptr->zbitpix,
+                                         Fptr->rice_blocksize);
+    Fptr->cn_compressed = 1;
+    return;
+}
+
+
+void init_output_buffer(PyObject* hdu, void** buf, size_t* bufsize) {
+    // Determines a good size for the output data buffer and allocates
+    // memory for it, returning the address and size of the allocated
+    // memory into **buf and *bufsize respectively.
+
+    PyObject* header = NULL;
+    char keyword[9];
+    char tmp[72];
+    int znaxis;
+    int compress_type;
+    int zbitpix;
+    int rice_blocksize = 0;
+    long long rowlen;
+    long long nrows;
+    long maxelem;
+    long tilelen;
+    unsigned long maxtilelen = 1;
+    int idx;
+
+    header = PyObject_GetAttrString(hdu, "_header");
+    if (header == NULL) {
+        return;
+    }
+
+    if (get_header_int(header, "ZNAXIS", &znaxis, 0,
+                       HDR_FAIL_KEY_MISSING | HDR_FAIL_VAL_NEGATIVE) != GET_HEADER_SUCCESS) {
+        goto fail;
+    }
+
+    if (znaxis > 999) {
+        PyErr_SetString(PyExc_ValueError, "ZNAXIS is greater than 999.");
+        goto fail;
+    }
+
+    for (idx = 1; idx <= znaxis; idx++) {
+        snprintf(keyword, 9, "ZTILE%u", idx);
+        if (get_header_long(header, keyword, &tilelen, 1, HDR_NOFLAG) == GET_HEADER_FAILED) {
+            goto fail;
+        }
+        maxtilelen *= tilelen;
+    }
+
+    if (get_header_string(header, "ZCMPTYPE", tmp, DEFAULT_COMPRESSION_TYPE, HDR_NOFLAG) == GET_HEADER_FAILED) {
+        goto fail;
+    }
+    compress_type = compress_type_from_string(tmp);
+    if (PyErr_Occurred()) {
+        goto fail;
+    }
+    if (compress_type == RICE_1) {
+        if (get_header_int(header, "ZVAL1", &rice_blocksize, 0, HDR_NOFLAG) == GET_HEADER_FAILED) {
+            goto fail;
+        }
+    }
+
+    /* Because we calculate the size of the buffer based on these values they
+       must not be negative. Otherwise it would wrap around during the casting
+       to size_t and give huge values. */
+    if (get_header_longlong(header, "NAXIS1", &rowlen, 0, HDR_FAIL_VAL_NEGATIVE) == GET_HEADER_FAILED) {
+        goto fail;
+    }
+    if (get_header_longlong(header, "NAXIS2", &nrows, 0, HDR_FAIL_VAL_NEGATIVE) == GET_HEADER_FAILED) {
+        goto fail;
+    }
+
+    // Get the ZBITPIX header value; if this is missing we're in trouble
+    if (get_header_int(header, "ZBITPIX", &zbitpix, 0, HDR_FAIL_KEY_MISSING) != GET_HEADER_SUCCESS) {
+        goto fail;
+    }
+
+    maxelem = imcomp_calc_max_elem(compress_type, maxtilelen, zbitpix,
+                                   rice_blocksize);
+
+    *bufsize = ((size_t) (rowlen * nrows) + (nrows * maxelem));
+
+    if (*bufsize < IOBUFLEN) {
+        // We must have a full FITS block at a minimum
+        *bufsize = IOBUFLEN;
+    } else if (*bufsize % IOBUFLEN != 0) {
+        // Still make sure to pad out to a multiple of 2880 byte blocks
+        // otherwise CFITSIO can get read errors when it tries to read
+        // a partial block that goes past the end of the file
+        *bufsize += ((size_t) (IOBUFLEN - (*bufsize % IOBUFLEN)));
+    }
+
+    *buf = calloc(*bufsize, sizeof(char));
+    if (*buf == NULL) {
+        // Checking if calloc failed.
+        PyErr_SetString(PyExc_MemoryError,
+                        "Failed to allocate memory for output data buffer.");
+        goto fail;
+    }
+
+fail:
+    Py_DECREF(header);
+    return;
+}
+
+
+void get_hdu_data_base(PyObject* hdu, void** buf, size_t* bufsize) {
+    // Given a pointer to an HDU object, returns a pointer to the deepest base
+    // array of that HDU's data array into **buf, and the size of that array
+    // into *bufsize.
+
+    PyArrayObject* data = NULL;
+    PyArrayObject* base;
+    PyArrayObject* tmp;
+
+    data = (PyArrayObject*) PyObject_GetAttrString(hdu, "compressed_data");
+    if (data == NULL) {
+        goto fail;
+    }
+
+    // Walk the array data bases until we find the lowest ndarray base; for
+    // CompImageHDUs there should always be at least one contiguous byte array
+    // allocated for the table and its heap
+    if (!PyObject_TypeCheck(data, &PyArray_Type)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "CompImageHDU.compressed_data must be a numpy.ndarray");
+        goto fail;
+    }
+
+    tmp = base = data;
+    while (PyObject_TypeCheck((PyObject*) tmp, &PyArray_Type)) {
+        base = tmp;
+        *bufsize = (size_t) PyArray_NBYTES(base);
+        tmp = (PyArrayObject*) PyArray_BASE(base);
+        if (tmp == NULL) {
+            break;
+        }
+    }
+
+    *buf = PyArray_DATA(base);
+fail:
+    Py_XDECREF(data);
+    return;
+}
+
+
+void open_from_hdu(fitsfile** fileptr, void** buf, size_t* bufsize,
+                   PyObject* hdu, tcolumn** columns, int mode) {
+
+    PyObject* header = NULL;
+    FITSfile* Fptr;
+
+    int status = 0;
+    long long rowlen;
+    long long nrows;
+    long long heapsize;
+    long long theap;
+
+    header = PyObject_GetAttrString(hdu, "_header");
+    if (header == NULL) {
+        goto fail;
+    }
+
+    if (get_header_longlong(header, "NAXIS1", &rowlen, 0, HDR_NOFLAG) == GET_HEADER_FAILED) {
+        goto fail;
+    }
+    if (get_header_longlong(header, "NAXIS2", &nrows, 0, HDR_NOFLAG) == GET_HEADER_FAILED) {
+        goto fail;
+    }
+
+    // The PCOUNT keyword contains the number of bytes in the table heap
+    if (get_header_longlong(header, "PCOUNT", &heapsize, 0, HDR_FAIL_VAL_NEGATIVE) == GET_HEADER_FAILED) {
+        goto fail;
+    }
+
+    // The THEAP keyword gives the offset of the heap from the beginning of
+    // the HDU data portion; normally this offset is 0 but it can be set
+    // to something else with THEAP
+    if (get_header_longlong(header, "THEAP", &theap, 0, HDR_NOFLAG) == GET_HEADER_FAILED) {
+        goto fail;
+    }
+
+    fits_create_memfile(fileptr, buf, bufsize, 0, realloc, &status);
+    if (status != 0) {
+        process_status_err(status);
+        goto fail;
+    }
+
+    Fptr = (*fileptr)->Fptr;
+
+    // Now we have some fun munging some of the elements in the fitsfile struct
+    Fptr->writemode = mode;
+    Fptr->open_count = 1;
+    Fptr->hdutype = BINARY_TBL;  /* This is a binary table HDU */
+    Fptr->lasthdu = 1;
+    Fptr->headstart[0] = 0;
+    Fptr->headend = 0;
+    Fptr->datastart = 0;  /* There is no header, data starts at 0 */
+    Fptr->origrows = Fptr->numrows = nrows;
+    Fptr->rowlength = rowlen;
+    if (theap != 0) {
+        Fptr->heapstart = theap;
+    } else {
+        Fptr->heapstart = rowlen * nrows;
+    }
+
+    Fptr->heapsize = heapsize;
+
+    // Configure the array of table column structs from the Astropy header
+    // instead of allowing CFITSIO to try to read from the header
+    tcolumns_from_header(*fileptr, header, columns);
+    if (PyErr_Occurred()) {
+        goto fail;
+    }
+
+    // If any errors occur in this function they'll bubble up from here to
+    // compression_decompress_hdu
+    configure_compression(*fileptr, header);
+
+fail:
+    Py_XDECREF(header);
+    return;
+}
+
+
+PyObject* compression_compress_hdu(PyObject* self, PyObject* args)
+{
+    PyObject* hdu;
+    PyObject* retval = NULL;
+    tcolumn* columns = NULL;
+
+    void* outbuf = NULL;
+    size_t outbufsize;
+
+    PyObject* tmp_indata;
+    PyArrayObject* indata = NULL;
+    PyArrayObject* tmp;
+    npy_intp znaxis;
+    int datatype;
+    int npdatatype;
+    unsigned long long heapsize;
+
+    fitsfile* fileptr = NULL;
+    FITSfile* Fptr = NULL;
+    int status = 0;
+
+    if (!PyArg_ParseTuple(args, "O:compression.compress_hdu", &hdu)) {
+        return NULL;
+    }
+
+    // For HDU compression never use CFITSIO to write directly to the file;
+    // although there's nothing wrong with CFITSIO, right now that would cause
+    // too much confusion to Astropy's internal book keeping.
+    // We just need to get the compressed bytes and Astropy will handle the
+    // writing of them.
+    init_output_buffer(hdu, &outbuf, &outbufsize);
+    if (outbuf == NULL) {
+        return NULL;
+    }
+
+    open_from_hdu(&fileptr, &outbuf, &outbufsize, hdu, &columns, READWRITE);
+    if (PyErr_Occurred()) {
+        goto fail;
+    }
+
+    Fptr = fileptr->Fptr;
+
+    bitpix_to_datatypes(Fptr->zbitpix, &datatype, &npdatatype);
+    if (PyErr_Occurred()) {
+        goto fail;
+    }
+
+    /* The data attribute could be something different from an array, i.e. None */
+    tmp_indata = PyObject_GetAttrString(hdu, "data");
+    if (tmp_indata == NULL) {
+        goto fail;
+    }
+
+    if (!PyObject_TypeCheck(tmp_indata, &PyArray_Type)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "CompImageHDU.data must be a numpy.ndarray");
+        Py_DECREF(tmp_indata);
+        goto fail;
+    }
+
+    indata = (PyArrayObject*) tmp_indata;
+
+    fits_write_img(fileptr, datatype, 1, PyArray_SIZE(indata),
+                   PyArray_DATA(indata), &status);
+    if (status != 0) {
+        process_status_err(status);
+        goto fail;
+    }
+
+    fits_flush_buffer(fileptr, 1, &status);
+    if (status != 0) {
+        process_status_err(status);
+        goto fail;
+    }
+
+    // Previously this used outbufsize as the size to use for the new Numpy
+    // byte array. However outbufsize is usually larger than necessary to
+    // store all the compressed data exactly; instead use the exact size
+    // of the compressed data from the heapsize plus the size of the table
+    // itself
+    heapsize = (unsigned long long) Fptr->heapsize;
+    znaxis = (npy_intp) (Fptr->heapstart + heapsize);
+
+    if (znaxis < outbufsize) {
+        void* tmp_outbuf = NULL;
+        // Go ahead and truncate to the size in znaxis to free the
+        // redundant allocation
+        if (znaxis == 0) {
+            /* This really shouldn't happen, but if it did, we would have a
+               problem because realloc would deallocate outbuf AND return NULL.
+               */
+            PyErr_SetString(PyExc_ValueError,
+                            "Calculated array size is zero. This shouldn't happen!");
+            goto fail;
+        }
+        tmp_outbuf = realloc(outbuf, (size_t) znaxis);
+        if (tmp_outbuf == NULL) {
+            PyErr_SetString(PyExc_MemoryError,
+                            "Couldn't resize the output-buffer.");
+            goto fail;
+        }
+        outbuf = tmp_outbuf;
+    }
+
+    tmp = (PyArrayObject*) PyArray_SimpleNewFromData(1, &znaxis, NPY_UBYTE,
+                                                     outbuf);
+    if (tmp == NULL) {
+        /* Really not sure if it's always safe to free outbuf when
+           PyArray_SimpleNewFromData failed (which is unlikely but could happen)
+           but it seems like if it fails then the outbuf NEEDS to be freed... */
+        goto fail;
+    }
+    PyArray_ENABLEFLAGS(tmp, NPY_ARRAY_OWNDATA);
+    /* From this point on outbuf MUST NOT BE FREED! */
+
+    // Leaves refcount of tmp untouched, so its refcount should remain as 1
+    retval = Py_BuildValue("KN", heapsize, tmp);
+    if (retval == NULL) {
+        Py_DECREF(tmp);
+        goto cleanup;
+    }
+
+    goto cleanup;
+
+fail:
+    if (outbuf != NULL) {
+        // At this point outbuf should never not be NULL, but in principle
+        // buggy code somewhere in CFITSIO or Numpy could set it to NULL
+        free(outbuf);
+    }
+cleanup:
+    if (columns != NULL) {
+        free(columns);
+        /* See https://github.com/astropy/astropy/pull/4489
+           We can only set the tableptr to NULL if Fptr is actually not NULL.
+           */
+        if (fileptr != NULL && fileptr->Fptr != NULL) {
+            fileptr->Fptr->tableptr = NULL;
+        }
+    }
+
+    if (fileptr != NULL) {
+        status = 1; // Disable header-related errors
+        fits_close_file(fileptr, &status);
+        if (status != 1) {
+            process_status_err(status);
+            retval = NULL;
+        }
+    }
+
+    Py_XDECREF(indata);
+
+    // Clear any messages remaining in CFITSIO's error stack
+    fits_clear_errmsg();
+
+    return retval;
+}
+
+
+PyObject* compression_decompress_hdu(PyObject* self, PyObject* args)
+{
+
+    PyObject* hdu;
+    tcolumn* columns = NULL;
+
+    void* inbuf;
+    size_t inbufsize;
+
+    PyArrayObject* outdata = NULL;
+    int datatype;
+    int npdatatype;
+    npy_intp zndim;
+    npy_intp* znaxis = NULL;
+    long arrsize;
+
+    fitsfile* fileptr = NULL;
+    int anynul = 0;
+    int status = 0;
+    int idx;
+
+    int free_columns_manually = 1;
+
+    if (!PyArg_ParseTuple(args, "O:compression.decompress_hdu", &hdu)) {
+        return NULL;
+    }
+
+    // Grab a pointer to the input data from the HDU's compressed_data
+    // attribute
+    get_hdu_data_base(hdu, &inbuf, &inbufsize);
+    if (PyErr_Occurred()) {
+        return NULL;
+    } else if (inbufsize == 0) {
+        // The compressed data buffer is empty (probably zero rows, for an
+        // empty "compressed" image.  Just return None in this case.
+        Py_RETURN_NONE;
+    }
+
+    open_from_hdu(&fileptr, &inbuf, &inbufsize, hdu, &columns, READONLY);
+    if (PyErr_Occurred()) {
+        goto fail;
+    }
+
+    bitpix_to_datatypes(fileptr->Fptr->zbitpix, &datatype, &npdatatype);
+    if (PyErr_Occurred()) {
+        goto fail;
+    }
+
+    zndim = (npy_intp)fileptr->Fptr->zndim;
+    znaxis = PyMem_Malloc(sizeof(npy_intp) * zndim);
+    if (znaxis == NULL) {
+        goto fail;
+    }
+
+    arrsize = 1;
+    for (idx = 0; idx < zndim; idx++) {
+        znaxis[zndim - idx - 1] = fileptr->Fptr->znaxis[idx];
+        arrsize *= fileptr->Fptr->znaxis[idx];
+    }
+
+    /* Create and allocate a new array for the decompressed data */
+    outdata = (PyArrayObject*) PyArray_SimpleNew(zndim, znaxis, npdatatype);
+    if (outdata == NULL) {
+        goto fail;
+    }
+
+    fits_read_img(fileptr, datatype, 1, arrsize, NULL, PyArray_DATA(outdata),
+                  &anynul, &status);
+    /* At this point we need to let CFITSIO clean up the tableptr and the
+       compressed tile cache. */
+    free_columns_manually = 0;
+    if (status != 0) {
+        process_status_err(status);
+        Py_DECREF(outdata);
+        outdata = NULL;
+    }
+
+fail:
+    // CFITSIO will free this object in the ffchdu function by way of
+    // fits_close_file; we need to let CFITSIO handle this so that it also
+    // cleans up the compressed tile cache - but that's only necessary in case
+    // we called "fits_read_img"...
+    if (free_columns_manually && columns != NULL) {
+        free(columns);
+        if (fileptr != NULL && fileptr->Fptr != NULL) {
+            fileptr->Fptr->tableptr = NULL;
+        }
+    }
+
+    if (fileptr != NULL) {
+        status = 1;// Disable header-related errors
+        fits_close_file(fileptr, &status);
+        if (status != 1) {
+            process_status_err(status);
+            outdata = NULL;
+        }
+    }
+
+    if (znaxis != NULL) {
+        PyMem_Free(znaxis);
+    }
+
+    // Clear any messages remaining in CFITSIO's error stack
+    fits_clear_errmsg();
+
+    return (PyObject*) outdata;
+}
+
+
+/* CFITSIO version float as returned by fits_get_version() */
+static double cfitsio_version;
+
+
+int compression_module_init(PyObject* module) {
+    /* Python version-independent initialization routine for the
+       compression module. Returns 0 on success and -1 (with exception set)
+       on failure. */
+    PyObject* tmp;
+    float version_tmp;
+    int ret;
+
+    fits_get_version(&version_tmp);
+    cfitsio_version = (double) version_tmp;
+    /* The conversion to double can lead to some rounding errors; round to the
+       nearest 3 decimal places, which should be accurate for any past or
+       current CFITSIO version. This is why relying on floats for version
+       comparison isn't generally a bright idea... */
+    cfitsio_version = floor((1000 * version_tmp + 0.5)) / 1000;
+
+    tmp = PyFloat_FromDouble(cfitsio_version);
+    if (tmp == NULL) {
+        return -1;
+    }
+    ret = PyObject_SetAttrString(module, "CFITSIO_VERSION", tmp);
+    Py_DECREF(tmp);
+    return ret;
+}
+
+
+/* Method table mapping names to wrappers */
+static PyMethodDef compression_methods[] =
+{
+   {"compress_hdu", compression_compress_hdu, METH_VARARGS},
+   {"decompress_hdu", compression_decompress_hdu, METH_VARARGS},
+   {NULL, NULL}
+};
+
+static struct PyModuleDef compressionmodule = {
+    PyModuleDef_HEAD_INIT,
+    "compression",
+    "astropy.compression module",
+    -1, /* No global state */
+    compression_methods
+};
+
+PyObject *
+PyInit_compression(void)
+{
+    PyObject* module = PyModule_Create(&compressionmodule);
+    if (module == NULL) {
+        return NULL;
+    }
+    if (compression_module_init(module)) {
+        Py_DECREF(module);
+        return NULL;
+    }
+
+    /* Needed to use Numpy routines */
+    /* Note -- import_array() is a macro that behaves differently in Python2.x
+     * vs. Python 3. See the discussion at:
+     * https://groups.google.com/d/topic/astropy-dev/6_AesAsCauM/discussion
+     */
+    import_array();
+    return module;
+}

testbed/astropy__astropy/astropy/io/fits/src/compressionmodule.h

@@ -0,0 +1,56 @@
+#ifndef _COMPRESSIONMODULE_H
+#define _COMPRESSIONMODULE_H
+
+
+/* CFITSIO version-specific feature support */
+#ifndef CFITSIO_MAJOR
+    // Define a minimized version
+    #define CFITSIO_MAJOR 0
+    #ifdef _MSC_VER
+        #pragma warning ( "CFITSIO_MAJOR not defined; your CFITSIO version may be too old; compile at your own risk" )
+    #else
+        #warning "CFITSIO_MAJOR not defined; your CFITSIO version may be too old; compile at your own risk"
+    #endif
+#endif
+
+#ifndef CFITSIO_MINOR
+    #define CFITSIO_MINOR 0
+#endif
+
+
+#if CFITSIO_MAJOR >= 3
+    #if CFITSIO_MINOR >= 35
+        #define CFITSIO_SUPPORTS_Q_FORMAT_COMPRESSION
+        #define CFITSIO_SUPPORTS_SUBTRACTIVE_DITHER_2
+    #else
+        /* This constant isn't defined in older versions and has a different */
+        /* value anyways. */
+        #define NO_DITHER 0
+    #endif
+    #if CFITSIO_MINOR >= 28
+        #define CFITSIO_SUPPORTS_GZIPDATA
+    #else
+        #ifdef _MSC_VER
+            #pragma warning ( "GZIP_COMPRESSED_DATA columns not supported" )
+        #else
+            #warning "GZIP_COMPRESSED_DATA columns not supported"
+        #endif
+    #endif
+#endif
+
+
+#define CFITSIO_LOSSLESS_COMP_SUPPORTED_VERS 3.22
+
+
+/* These defaults mirror the defaults in io.fits.hdu.compressed */
+#define DEFAULT_COMPRESSION_TYPE "RICE_1"
+#define DEFAULT_QUANTIZE_LEVEL 16.0
+#define DEFAULT_HCOMP_SCALE 0
+#define DEFAULT_HCOMP_SMOOTH 0
+#define DEFAULT_BLOCK_SIZE 32
+#define DEFAULT_BYTE_PIX 4
+
+/* This constant is defined by cfitsio in imcompress.c */
+#define NO_QUANTIZE 9999
+
+#endif

testbed/astropy__astropy/astropy/io/fits/tests/__init__.py

@@ -0,0 +1,60 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import os
+import shutil
+import stat
+import tempfile
+import time
+
+from astropy.io import fits
+
+
+class FitsTestCase:
+    def setup(self):
+        self.data_dir = os.path.join(os.path.dirname(__file__), 'data')
+        self.temp_dir = tempfile.mkdtemp(prefix='fits-test-')
+
+        # Restore global settings to defaults
+        # TODO: Replace this when there's a better way to in the config API to
+        # force config values to their defaults
+        fits.conf.enable_record_valued_keyword_cards = True
+        fits.conf.extension_name_case_sensitive = False
+        fits.conf.strip_header_whitespace = True
+        fits.conf.use_memmap = True
+
+    def teardown(self):
+        if hasattr(self, 'temp_dir') and os.path.exists(self.temp_dir):
+            tries = 3
+            while tries:
+                try:
+                    shutil.rmtree(self.temp_dir)
+                    break
+                except OSError:
+                    # Probably couldn't delete the file because for whatever
+                    # reason a handle to it is still open/hasn't been
+                    # garbage-collected
+                    time.sleep(0.5)
+                    tries -= 1
+
+        fits.conf.reset('enable_record_valued_keyword_cards')
+        fits.conf.reset('extension_name_case_sensitive')
+        fits.conf.reset('strip_header_whitespace')
+        fits.conf.reset('use_memmap')
+
+    def copy_file(self, filename):
+        """Copies a backup of a test data file to the temp dir and sets its
+        mode to writeable.
+        """
+
+        shutil.copy(self.data(filename), self.temp(filename))
+        os.chmod(self.temp(filename), stat.S_IREAD | stat.S_IWRITE)
+
+    def data(self, filename):
+        """Returns the path to a test data file."""
+
+        return os.path.join(self.data_dir, filename)
+
+    def temp(self, filename):
+        """ Returns the full path to a file in the test temp dir."""
+
+        return os.path.join(self.temp_dir, filename)

testbed/astropy__astropy/astropy/io/fits/tests/cfitsio_verify.c

@@ -0,0 +1,74 @@
+/* This script verifies .fits checksums using CFITSIO to demonstrate
+compatibility with Astropy.   Since running it requires compiling and
+linking against cfitsio,  the script is included as a maintenance
+asset but not automatically compiled and run.
+
+After installing cfitsio to ~/include and ~/lib,  I built cfitsio_verify
+like this:
+
+% gcc cfitsio_verify.c -I~/include -L~/lib -lcfitsio -lm -o cfitsio_verify
+
+Run cfitsio_verify like this:
+
+% cfitsio_verify tmp.fits
+
+TODO: Compile this as an optional extension module and write unit tests that
+use it; if compilation fails any such tests should be skipped.
+
+*/
+
+#include <fitsio.h>
+
+char * verify_status(int status)
+{
+	if (status == 1) {
+		return "ok";
+	} else if (status == 0) {
+		return "missing";
+	} else if (status == -1) {
+		return "error";
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	fitsfile *fptr;
+	int i, j, status, dataok, hduok, hdunum, hdutype;
+	char *hdustr, *datastr;
+
+	for (i=1; i<argc; i++) {
+
+		fits_open_file(&fptr, argv[i], READONLY, &status);
+		if (status) {
+			fits_report_error(stderr, status);
+			exit(-1);
+		}
+
+		fits_get_num_hdus(fptr, &hdunum, &status);
+		if (status) {
+			fprintf(stderr, "Bad get_num_hdus status for '%s' = %d",
+				argv[i], status);
+			exit(-1);
+		}
+
+		for (j=0; j<hdunum; j++) {
+			fits_movabs_hdu(fptr, hdunum, &hdutype, &status);
+			if (status) {
+				fprintf(stderr, "Bad movabs status for '%s[%d]' = %d.",
+					argv[i], j, status);
+				exit(-1);
+			}
+			fits_verify_chksum(fptr, &dataok, &hduok, &status);
+			if (status) {
+				fprintf(stderr, "Bad verify status for '%s[%d]' = %d.",
+					argv[i], j, status);
+				exit(-1);
+			}
+			datastr = verify_status(dataok);
+			hdustr = verify_status(hduok);
+			printf("Verifying '%s[%d]'  data='%s'   hdu='%s'.\n",
+			       argv[i], j, datastr, hdustr);
+		}
+	}
+}
+

testbed/astropy__astropy/astropy/io/fits/tests/test_checksum.py

@@ -0,0 +1,457 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import sys
+import warnings
+
+import pytest
+import numpy as np
+
+from .test_table import comparerecords
+from astropy.io.fits.hdu.base import _ValidHDU
+from astropy.io import fits
+
+from . import FitsTestCase
+
+
+class TestChecksumFunctions(FitsTestCase):
+
+    # All checksums have been verified against CFITSIO
+    def setup(self):
+        super().setup()
+        self._oldfilters = warnings.filters[:]
+        warnings.filterwarnings(
+            'error',
+            message='Checksum verification failed')
+        warnings.filterwarnings(
+            'error',
+            message='Datasum verification failed')
+
+        # Monkey-patch the _get_timestamp method so that the checksum
+        # timestamps (and hence the checksum themselves) are always the same
+        self._old_get_timestamp = _ValidHDU._get_timestamp
+        _ValidHDU._get_timestamp = lambda self: '2013-12-20T13:36:10'
+
+    def teardown(self):
+        super().teardown()
+        warnings.filters = self._oldfilters
+        _ValidHDU._get_timestamp = self._old_get_timestamp
+
+    def test_sample_file(self):
+        hdul = fits.open(self.data('checksum.fits'), checksum=True)
+        hdul.close()
+
+    def test_image_create(self):
+        n = np.arange(100, dtype=np.int64)
+        hdu = fits.PrimaryHDU(n)
+        hdu.writeto(self.temp('tmp.fits'), overwrite=True, checksum=True)
+        with fits.open(self.temp('tmp.fits'), checksum=True) as hdul:
+            assert (hdu.data == hdul[0].data).all()
+            assert 'CHECKSUM' in hdul[0].header
+            assert 'DATASUM' in hdul[0].header
+
+            if not sys.platform.startswith('win32'):
+                # The checksum ends up being different on Windows, possibly due
+                # to slight floating point differences
+                assert hdul[0].header['CHECKSUM'] == 'ZHMkeGKjZGKjbGKj'
+                assert hdul[0].header['DATASUM'] == '4950'
+
+    def test_scaled_data(self):
+        with fits.open(self.data('scale.fits')) as hdul:
+            orig_data = hdul[0].data.copy()
+            hdul[0].scale('int16', 'old')
+            hdul.writeto(self.temp('tmp.fits'), overwrite=True, checksum=True)
+            with fits.open(self.temp('tmp.fits'), checksum=True) as hdul1:
+                assert (hdul1[0].data == orig_data).all()
+                assert 'CHECKSUM' in hdul1[0].header
+                assert hdul1[0].header['CHECKSUM'] == 'cUmaeUjZcUjacUjW'
+                assert 'DATASUM' in hdul1[0].header
+                assert hdul1[0].header['DATASUM'] == '1891563534'
+
+    def test_scaled_data_auto_rescale(self):
+        """
+        Regression test for
+        https://github.com/astropy/astropy/issues/3883#issuecomment-115122647
+
+        Ensure that when scaled data is automatically rescaled on
+        opening/writing a file that the checksum and datasum are computed for
+        the rescaled array.
+        """
+
+        with fits.open(self.data('scale.fits')) as hdul:
+            # Write out a copy of the data with the rescaling applied
+            hdul.writeto(self.temp('rescaled.fits'))
+
+        # Reopen the new file and save it back again with a checksum
+        with fits.open(self.temp('rescaled.fits')) as hdul:
+            hdul.writeto(self.temp('rescaled2.fits'), overwrite=True,
+                         checksum=True)
+
+        # Now do like in the first writeto but use checksum immediately
+        with fits.open(self.data('scale.fits')) as hdul:
+            hdul.writeto(self.temp('rescaled3.fits'), checksum=True)
+
+        # Also don't rescale the data but add a checksum
+        with fits.open(self.data('scale.fits'),
+                       do_not_scale_image_data=True) as hdul:
+            hdul.writeto(self.temp('scaled.fits'), checksum=True)
+
+        # Must used nested with statements to support older Python versions
+        # (but contextlib.nested is not available in newer Pythons :(
+        with fits.open(self.temp('rescaled2.fits')) as hdul1:
+            with fits.open(self.temp('rescaled3.fits')) as hdul2:
+                with fits.open(self.temp('scaled.fits')) as hdul3:
+                    hdr1 = hdul1[0].header
+                    hdr2 = hdul2[0].header
+                    hdr3 = hdul3[0].header
+                    assert hdr1['DATASUM'] == hdr2['DATASUM']
+                    assert hdr1['CHECKSUM'] == hdr2['CHECKSUM']
+                    assert hdr1['DATASUM'] != hdr3['DATASUM']
+                    assert hdr1['CHECKSUM'] != hdr3['CHECKSUM']
+
+    def test_uint16_data(self):
+        checksums = [
+            ('aDcXaCcXaCcXaCcX', '0'), ('oYiGqXi9oXiEoXi9', '1746888714'),
+            ('VhqQWZoQVfoQVZoQ', '0'), ('4cPp5aOn4aOn4aOn', '0'),
+            ('8aCN8X9N8aAN8W9N', '1756785133'), ('UhqdUZnbUfnbUZnb', '0'),
+            ('4cQJ5aN94aNG4aN9', '0')]
+        with fits.open(self.data('o4sp040b0_raw.fits'), uint=True) as hdul:
+            hdul.writeto(self.temp('tmp.fits'), overwrite=True, checksum=True)
+            with fits.open(self.temp('tmp.fits'), uint=True,
+                           checksum=True) as hdul1:
+                for idx, (hdu_a, hdu_b) in enumerate(zip(hdul, hdul1)):
+                    if hdu_a.data is None or hdu_b.data is None:
+                        assert hdu_a.data is hdu_b.data
+                    else:
+                        assert (hdu_a.data == hdu_b.data).all()
+
+                    assert 'CHECKSUM' in hdul[idx].header
+                    assert hdul[idx].header['CHECKSUM'] == checksums[idx][0]
+                    assert 'DATASUM' in hdul[idx].header
+                    assert hdul[idx].header['DATASUM'] == checksums[idx][1]
+
+    def test_groups_hdu_data(self):
+        imdata = np.arange(100.0)
+        imdata.shape = (10, 1, 1, 2, 5)
+        pdata1 = np.arange(10) + 0.1
+        pdata2 = 42
+        x = fits.hdu.groups.GroupData(imdata, parnames=[str('abc'), str('xyz')],
+                                      pardata=[pdata1, pdata2], bitpix=-32)
+        hdu = fits.GroupsHDU(x)
+        hdu.writeto(self.temp('tmp.fits'), overwrite=True, checksum=True)
+        with fits.open(self.temp('tmp.fits'), checksum=True) as hdul:
+            assert comparerecords(hdul[0].data, hdu.data)
+            assert 'CHECKSUM' in hdul[0].header
+            assert hdul[0].header['CHECKSUM'] == '3eDQAZDO4dDOAZDO'
+            assert 'DATASUM' in hdul[0].header
+            assert hdul[0].header['DATASUM'] == '2797758084'
+
+    def test_binary_table_data(self):
+        a1 = np.array(['NGC1001', 'NGC1002', 'NGC1003'])
+        a2 = np.array([11.1, 12.3, 15.2])
+        col1 = fits.Column(name='target', format='20A', array=a1)
+        col2 = fits.Column(name='V_mag', format='E', array=a2)
+        cols = fits.ColDefs([col1, col2])
+        tbhdu = fits.BinTableHDU.from_columns(cols)
+        tbhdu.writeto(self.temp('tmp.fits'), overwrite=True, checksum=True)
+        with fits.open(self.temp('tmp.fits'), checksum=True) as hdul:
+            assert comparerecords(tbhdu.data, hdul[1].data)
+            assert 'CHECKSUM' in hdul[0].header
+            assert hdul[0].header['CHECKSUM'] == 'D8iBD6ZAD6fAD6ZA'
+            assert 'DATASUM' in hdul[0].header
+            assert hdul[0].header['DATASUM'] == '0'
+            assert 'CHECKSUM' in hdul[1].header
+            assert hdul[1].header['CHECKSUM'] == 'aD1Oa90MaC0Ma90M'
+            assert 'DATASUM' in hdul[1].header
+            assert hdul[1].header['DATASUM'] == '1062205743'
+
+    def test_variable_length_table_data(self):
+        c1 = fits.Column(name='var', format='PJ()',
+                         array=np.array([[45.0, 56], np.array([11, 12, 13])],
+                         'O'))
+        c2 = fits.Column(name='xyz', format='2I', array=[[11, 3], [12, 4]])
+        tbhdu = fits.BinTableHDU.from_columns([c1, c2])
+        tbhdu.writeto(self.temp('tmp.fits'), overwrite=True, checksum=True)
+        with fits.open(self.temp('tmp.fits'), checksum=True) as hdul:
+            assert comparerecords(tbhdu.data, hdul[1].data)
+            assert 'CHECKSUM' in hdul[0].header
+            assert hdul[0].header['CHECKSUM'] == 'D8iBD6ZAD6fAD6ZA'
+            assert 'DATASUM' in hdul[0].header
+            assert hdul[0].header['DATASUM'] == '0'
+            assert 'CHECKSUM' in hdul[1].header
+            assert hdul[1].header['CHECKSUM'] == 'YIGoaIEmZIEmaIEm'
+            assert 'DATASUM' in hdul[1].header
+            assert hdul[1].header['DATASUM'] == '1507485'
+
+    def test_ascii_table_data(self):
+        a1 = np.array(['abc', 'def'])
+        r1 = np.array([11.0, 12.0])
+        c1 = fits.Column(name='abc', format='A3', array=a1)
+        # This column used to be E format, but the single-precision float lost
+        # too much precision when scaling so it was changed to a D
+        c2 = fits.Column(name='def', format='D', array=r1, bscale=2.3,
+                         bzero=0.6)
+        c3 = fits.Column(name='t1', format='I', array=[91, 92, 93])
+        x = fits.ColDefs([c1, c2, c3])
+        hdu = fits.TableHDU.from_columns(x)
+        hdu.writeto(self.temp('tmp.fits'), overwrite=True, checksum=True)
+        with fits.open(self.temp('tmp.fits'), checksum=True) as hdul:
+            assert comparerecords(hdu.data, hdul[1].data)
+            assert 'CHECKSUM' in hdul[0].header
+            assert hdul[0].header['CHECKSUM'] == 'D8iBD6ZAD6fAD6ZA'
+            assert 'DATASUM' in hdul[0].header
+            assert hdul[0].header['DATASUM'] == '0'
+
+            if not sys.platform.startswith('win32'):
+                # The checksum ends up being different on Windows, possibly due
+                # to slight floating point differences
+                assert 'CHECKSUM' in hdul[1].header
+                assert hdul[1].header['CHECKSUM'] == '3rKFAoI94oICAoI9'
+                assert 'DATASUM' in hdul[1].header
+                assert hdul[1].header['DATASUM'] == '1914653725'
+
+    def test_compressed_image_data(self):
+        with fits.open(self.data('comp.fits')) as h1:
+            h1.writeto(self.temp('tmp.fits'), overwrite=True, checksum=True)
+            with fits.open(self.temp('tmp.fits'), checksum=True) as h2:
+                assert np.all(h1[1].data == h2[1].data)
+                assert 'CHECKSUM' in h2[0].header
+                assert h2[0].header['CHECKSUM'] == 'D8iBD6ZAD6fAD6ZA'
+                assert 'DATASUM' in h2[0].header
+                assert h2[0].header['DATASUM'] == '0'
+                assert 'CHECKSUM' in h2[1].header
+                assert h2[1].header['CHECKSUM'] == 'ZeAbdb8aZbAabb7a'
+                assert 'DATASUM' in h2[1].header
+                assert h2[1].header['DATASUM'] == '113055149'
+
+    def test_compressed_image_data_int16(self):
+        n = np.arange(100, dtype='int16')
+        hdu = fits.ImageHDU(n)
+        comp_hdu = fits.CompImageHDU(hdu.data, hdu.header)
+        comp_hdu.writeto(self.temp('tmp.fits'), checksum=True)
+        hdu.writeto(self.temp('uncomp.fits'), checksum=True)
+        with fits.open(self.temp('tmp.fits'), checksum=True) as hdul:
+            assert np.all(hdul[1].data == comp_hdu.data)
+            assert np.all(hdul[1].data == hdu.data)
+            assert 'CHECKSUM' in hdul[0].header
+            assert hdul[0].header['CHECKSUM'] == 'D8iBD6ZAD6fAD6ZA'
+            assert 'DATASUM' in hdul[0].header
+            assert hdul[0].header['DATASUM'] == '0'
+
+            assert 'CHECKSUM' in hdul[1].header
+            assert hdul[1]._header['CHECKSUM'] == 'J5cCJ5c9J5cAJ5c9'
+            assert 'DATASUM' in hdul[1].header
+            assert hdul[1]._header['DATASUM'] == '2453673070'
+            assert 'CHECKSUM' in hdul[1].header
+
+            with fits.open(self.temp('uncomp.fits'), checksum=True) as hdul2:
+                header_comp = hdul[1]._header
+                header_uncomp = hdul2[1].header
+                assert 'ZHECKSUM' in header_comp
+                assert 'CHECKSUM' in header_uncomp
+                assert header_uncomp['CHECKSUM'] == 'ZE94eE91ZE91bE91'
+                assert header_comp['ZHECKSUM'] == header_uncomp['CHECKSUM']
+                assert 'ZDATASUM' in header_comp
+                assert 'DATASUM' in header_uncomp
+                assert header_uncomp['DATASUM'] == '160565700'
+                assert header_comp['ZDATASUM'] == header_uncomp['DATASUM']
+
+    def test_compressed_image_data_float32(self):
+        n = np.arange(100, dtype='float32')
+        hdu = fits.ImageHDU(n)
+        comp_hdu = fits.CompImageHDU(hdu.data, hdu.header)
+        comp_hdu.writeto(self.temp('tmp.fits'), checksum=True)
+        hdu.writeto(self.temp('uncomp.fits'), checksum=True)
+        with fits.open(self.temp('tmp.fits'), checksum=True) as hdul:
+            assert np.all(hdul[1].data == comp_hdu.data)
+            assert np.all(hdul[1].data == hdu.data)
+            assert 'CHECKSUM' in hdul[0].header
+            assert hdul[0].header['CHECKSUM'] == 'D8iBD6ZAD6fAD6ZA'
+            assert 'DATASUM' in hdul[0].header
+            assert hdul[0].header['DATASUM'] == '0'
+
+            assert 'CHECKSUM' in hdul[1].header
+            assert 'DATASUM' in hdul[1].header
+
+            if not sys.platform.startswith('win32'):
+                # The checksum ends up being different on Windows, possibly due
+                # to slight floating point differences
+                assert hdul[1]._header['CHECKSUM'] == 'eATIf3SHe9SHe9SH'
+                assert hdul[1]._header['DATASUM'] == '1277667818'
+
+            with fits.open(self.temp('uncomp.fits'), checksum=True) as hdul2:
+                header_comp = hdul[1]._header
+                header_uncomp = hdul2[1].header
+                assert 'ZHECKSUM' in header_comp
+                assert 'CHECKSUM' in header_uncomp
+                assert header_uncomp['CHECKSUM'] == 'Cgr5FZo2Cdo2CZo2'
+                assert header_comp['ZHECKSUM'] == header_uncomp['CHECKSUM']
+                assert 'ZDATASUM' in header_comp
+                assert 'DATASUM' in header_uncomp
+                assert header_uncomp['DATASUM'] == '2393636889'
+                assert header_comp['ZDATASUM'] == header_uncomp['DATASUM']
+
+    def test_open_with_no_keywords(self):
+        hdul = fits.open(self.data('arange.fits'), checksum=True)
+        hdul.close()
+
+    def test_append(self):
+        hdul = fits.open(self.data('tb.fits'))
+        hdul.writeto(self.temp('tmp.fits'), overwrite=True)
+        n = np.arange(100)
+        fits.append(self.temp('tmp.fits'), n, checksum=True)
+        hdul.close()
+        hdul = fits.open(self.temp('tmp.fits'), checksum=True)
+        assert hdul[0]._checksum is None
+        hdul.close()
+
+    def test_writeto_convenience(self):
+        n = np.arange(100)
+        fits.writeto(self.temp('tmp.fits'), n, overwrite=True, checksum=True)
+        hdul = fits.open(self.temp('tmp.fits'), checksum=True)
+        self._check_checksums(hdul[0])
+        hdul.close()
+
+    def test_hdu_writeto(self):
+        n = np.arange(100, dtype='int16')
+        hdu = fits.ImageHDU(n)
+        hdu.writeto(self.temp('tmp.fits'), checksum=True)
+        hdul = fits.open(self.temp('tmp.fits'), checksum=True)
+        self._check_checksums(hdul[0])
+        hdul.close()
+
+    def test_hdu_writeto_existing(self):
+        """
+        Tests that when using writeto with checksum=True, a checksum and
+        datasum are added to HDUs that did not previously have one.
+
+        Regression test for https://github.com/spacetelescope/PyFITS/issues/8
+        """
+
+        with fits.open(self.data('tb.fits')) as hdul:
+            hdul.writeto(self.temp('test.fits'), checksum=True)
+
+        with fits.open(self.temp('test.fits')) as hdul:
+            assert 'CHECKSUM' in hdul[0].header
+            # These checksums were verified against CFITSIO
+            assert hdul[0].header['CHECKSUM'] == '7UgqATfo7TfoATfo'
+            assert 'DATASUM' in hdul[0].header
+            assert hdul[0].header['DATASUM'] == '0'
+            assert 'CHECKSUM' in hdul[1].header
+            assert hdul[1].header['CHECKSUM'] == '99daD8bX98baA8bU'
+            assert 'DATASUM' in hdul[1].header
+            assert hdul[1].header['DATASUM'] == '1829680925'
+
+    def test_datasum_only(self):
+        n = np.arange(100, dtype='int16')
+        hdu = fits.ImageHDU(n)
+        hdu.writeto(self.temp('tmp.fits'), overwrite=True, checksum='datasum')
+        with fits.open(self.temp('tmp.fits'), checksum=True) as hdul:
+            if not (hasattr(hdul[0], '_datasum') and hdul[0]._datasum):
+                pytest.fail(msg='Missing DATASUM keyword')
+
+            if not (hasattr(hdul[0], '_checksum') and not hdul[0]._checksum):
+                pytest.fail(msg='Non-empty CHECKSUM keyword')
+
+    def test_open_update_mode_preserve_checksum(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/148 where
+        checksums are being removed from headers when a file is opened in
+        update mode, even though no changes were made to the file.
+        """
+
+        self.copy_file('checksum.fits')
+
+        with fits.open(self.temp('checksum.fits')) as hdul:
+            data = hdul[1].data.copy()
+
+        hdul = fits.open(self.temp('checksum.fits'), mode='update')
+        hdul.close()
+
+        with fits.open(self.temp('checksum.fits')) as hdul:
+            assert 'CHECKSUM' in hdul[1].header
+            assert 'DATASUM' in hdul[1].header
+            assert comparerecords(data, hdul[1].data)
+
+    def test_open_update_mode_update_checksum(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/148, part
+        2.  This ensures that if a file contains a checksum, the checksum is
+        updated when changes are saved to the file, even if the file was opened
+        with the default of checksum=False.
+
+        An existing checksum and/or datasum are only stripped if the file is
+        opened with checksum='remove'.
+        """
+
+        self.copy_file('checksum.fits')
+        with fits.open(self.temp('checksum.fits')) as hdul:
+            header = hdul[1].header.copy()
+            data = hdul[1].data.copy()
+
+        with fits.open(self.temp('checksum.fits'), mode='update') as hdul:
+            hdul[1].header['FOO'] = 'BAR'
+            hdul[1].data[0]['TIME'] = 42
+
+        with fits.open(self.temp('checksum.fits')) as hdul:
+            header2 = hdul[1].header
+            data2 = hdul[1].data
+            assert header2[:-3] == header[:-2]
+            assert 'CHECKSUM' in header2
+            assert 'DATASUM' in header2
+            assert header2['FOO'] == 'BAR'
+            assert (data2['TIME'][1:] == data['TIME'][1:]).all()
+            assert data2['TIME'][0] == 42
+
+        with fits.open(self.temp('checksum.fits'), mode='update',
+                       checksum='remove') as hdul:
+            pass
+
+        with fits.open(self.temp('checksum.fits')) as hdul:
+            header2 = hdul[1].header
+            data2 = hdul[1].data
+            assert header2[:-1] == header[:-2]
+            assert 'CHECKSUM' not in header2
+            assert 'DATASUM' not in header2
+            assert header2['FOO'] == 'BAR'
+            assert (data2['TIME'][1:] == data['TIME'][1:]).all()
+            assert data2['TIME'][0] == 42
+
+    def test_overwrite_invalid(self):
+        """
+        Tests that invalid checksum or datasum are overwriten when the file is
+        saved.
+        """
+
+        reffile = self.temp('ref.fits')
+        with fits.open(self.data('tb.fits')) as hdul:
+            hdul.writeto(reffile, checksum=True)
+
+        testfile = self.temp('test.fits')
+        with fits.open(self.data('tb.fits')) as hdul:
+            hdul[0].header['DATASUM'] = '1       '
+            hdul[0].header['CHECKSUM'] = '8UgqATfo7TfoATfo'
+            hdul[1].header['DATASUM'] = '2349680925'
+            hdul[1].header['CHECKSUM'] = '11daD8bX98baA8bU'
+            hdul.writeto(testfile)
+
+        with fits.open(testfile) as hdul:
+            hdul.writeto(self.temp('test2.fits'), checksum=True)
+
+        with fits.open(self.temp('test2.fits')) as hdul:
+            with fits.open(reffile) as ref:
+                assert 'CHECKSUM' in hdul[0].header
+                # These checksums were verified against CFITSIO
+                assert hdul[0].header['CHECKSUM'] == ref[0].header['CHECKSUM']
+                assert 'DATASUM' in hdul[0].header
+                assert hdul[0].header['DATASUM'] == '0'
+                assert 'CHECKSUM' in hdul[1].header
+                assert hdul[1].header['CHECKSUM'] == ref[1].header['CHECKSUM']
+                assert 'DATASUM' in hdul[1].header
+                assert hdul[1].header['DATASUM'] == ref[1].header['DATASUM']
+
+    def _check_checksums(self, hdu):
+        if not (hasattr(hdu, '_datasum') and hdu._datasum):
+            pytest.fail(msg='Missing DATASUM keyword')
+
+        if not (hasattr(hdu, '_checksum') and hdu._checksum):
+            pytest.fail(msg='Missing CHECKSUM keyword')

testbed/astropy__astropy/astropy/io/fits/tests/test_compression_failures.py

@@ -0,0 +1,138 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import pytest
+import numpy as np
+
+from astropy.io import fits
+from astropy.io.fits.compression import compress_hdu
+
+from . import FitsTestCase
+
+
+MAX_INT = np.iinfo(np.intc).max
+MAX_LONG = np.iinfo(np.long).max
+MAX_LONGLONG = np.iinfo(np.longlong).max
+
+
+class TestCompressionFunction(FitsTestCase):
+    def test_wrong_argument_number(self):
+        with pytest.raises(TypeError):
+            compress_hdu(1, 2)
+
+    def test_unknown_compression_type(self):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu._header['ZCMPTYPE'] = 'fun'
+        with pytest.raises(ValueError) as exc:
+            compress_hdu(hdu)
+        assert 'Unrecognized compression type: fun' in str(exc)
+
+    def test_zbitpix_unknown(self):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu._header['ZBITPIX'] = 13
+        with pytest.raises(ValueError) as exc:
+            compress_hdu(hdu)
+        assert 'Invalid value for BITPIX: 13' in str(exc)
+
+    def test_data_none(self):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu.data = None
+        with pytest.raises(TypeError) as exc:
+            compress_hdu(hdu)
+        assert 'CompImageHDU.data must be a numpy.ndarray' in str(exc)
+
+    def test_missing_internal_header(self):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        del hdu._header
+        with pytest.raises(AttributeError) as exc:
+            compress_hdu(hdu)
+        assert '_header' in str(exc)
+
+    def test_invalid_tform(self):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu._header['TFORM1'] = 'TX'
+        with pytest.raises(RuntimeError) as exc:
+            compress_hdu(hdu)
+        assert 'TX' in str(exc) and 'TFORM' in str(exc)
+
+    def test_invalid_zdither(self):
+        hdu = fits.CompImageHDU(np.ones((10, 10)), quantize_method=1)
+        hdu._header['ZDITHER0'] = 'a'
+        with pytest.raises(TypeError):
+            compress_hdu(hdu)
+
+    @pytest.mark.parametrize('kw', ['ZNAXIS', 'ZBITPIX'])
+    def test_header_missing_keyword(self, kw):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        del hdu._header[kw]
+        with pytest.raises(KeyError) as exc:
+            compress_hdu(hdu)
+        assert kw in str(exc)
+
+    @pytest.mark.parametrize('kw', ['ZNAXIS', 'ZVAL1', 'ZVAL2', 'ZBLANK', 'BLANK'])
+    def test_header_value_int_overflow(self, kw):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu._header[kw] = MAX_INT + 1
+        with pytest.raises(OverflowError):
+            compress_hdu(hdu)
+
+    @pytest.mark.parametrize('kw', ['ZTILE1', 'ZNAXIS1'])
+    def test_header_value_long_overflow(self, kw):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu._header[kw] = MAX_LONG + 1
+        with pytest.raises(OverflowError):
+            compress_hdu(hdu)
+
+    @pytest.mark.parametrize('kw', ['NAXIS1', 'NAXIS2', 'TNULL1', 'PCOUNT', 'THEAP'])
+    def test_header_value_longlong_overflow(self, kw):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu._header[kw] = MAX_LONGLONG + 1
+        with pytest.raises(OverflowError):
+            compress_hdu(hdu)
+
+    @pytest.mark.parametrize('kw', ['ZVAL3'])
+    def test_header_value_float_overflow(self, kw):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu._header[kw] = 1e300
+        with pytest.raises(OverflowError):
+            compress_hdu(hdu)
+
+    @pytest.mark.parametrize('kw', ['NAXIS1', 'NAXIS2', 'TFIELDS', 'PCOUNT'])
+    def test_header_value_negative(self, kw):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu._header[kw] = -1
+        with pytest.raises(ValueError) as exc:
+            compress_hdu(hdu)
+        assert '{} should not be negative.'.format(kw) in str(exc)
+
+    @pytest.mark.parametrize(
+        ('kw', 'limit'),
+        [('ZNAXIS', 999),
+         ('TFIELDS', 999)])
+    def test_header_value_exceeds_custom_limit(self, kw, limit):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu._header[kw] = limit + 1
+        with pytest.raises(ValueError) as exc:
+            compress_hdu(hdu)
+        assert kw in str(exc)
+
+    @pytest.mark.parametrize('kw', ['TTYPE1', 'TFORM1', 'ZCMPTYPE', 'ZNAME1',
+                                    'ZQUANTIZ'])
+    def test_header_value_no_string(self, kw):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu._header[kw] = 1
+        with pytest.raises(TypeError):
+            compress_hdu(hdu)
+
+    @pytest.mark.parametrize('kw', ['TZERO1', 'TSCAL1'])
+    def test_header_value_no_double(self, kw):
+        hdu = fits.CompImageHDU(np.ones((10, 10)))
+        hdu._header[kw] = '1'
+        with pytest.raises(TypeError):
+            compress_hdu(hdu)
+
+    @pytest.mark.parametrize('kw', ['ZSCALE', 'ZZERO'])
+    def test_header_value_no_double_int_image(self, kw):
+        hdu = fits.CompImageHDU(np.ones((10, 10), dtype=np.int32))
+        hdu._header[kw] = '1'
+        with pytest.raises(TypeError):
+            compress_hdu(hdu)

testbed/astropy__astropy/astropy/io/fits/tests/test_connect.py

@@ -0,0 +1,696 @@
+import os
+import gc
+import pathlib
+import warnings
+
+import pytest
+import numpy as np
+from numpy.testing import assert_allclose
+
+from astropy.io.fits.column import (_parse_tdisp_format, _fortran_to_python_format,
+                                    python_to_tdisp)
+
+from astropy.io.fits import HDUList, PrimaryHDU, BinTableHDU
+
+from astropy.io import fits
+
+from astropy import units as u
+from astropy.table import Table, QTable, NdarrayMixin, Column
+from astropy.table.table_helpers import simple_table
+from astropy.tests.helper import catch_warnings
+from astropy.units.format.fits import UnitScaleError
+from astropy.utils.exceptions import AstropyUserWarning
+
+from astropy.coordinates import SkyCoord, Latitude, Longitude, Angle, EarthLocation
+from astropy.time import Time, TimeDelta
+from astropy.units.quantity import QuantityInfo
+
+try:
+    import yaml  # pylint: disable=W0611  # noqa
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+
+DATA = os.path.join(os.path.dirname(__file__), 'data')
+
+
+def equal_data(a, b):
+    for name in a.dtype.names:
+        if not np.all(a[name] == b[name]):
+            return False
+    return True
+
+
+class TestSingleTable:
+
+    def setup_class(self):
+        self.data = 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)])
+
+    def test_simple(self, tmpdir):
+        filename = str(tmpdir.join('test_simple.fts'))
+        t1 = Table(self.data)
+        t1.write(filename, overwrite=True)
+        t2 = Table.read(filename)
+        assert equal_data(t1, t2)
+
+    def test_simple_pathlib(self, tmpdir):
+        filename = pathlib.Path(str(tmpdir.join('test_simple.fit')))
+        t1 = Table(self.data)
+        t1.write(filename, overwrite=True)
+        t2 = Table.read(filename)
+        assert equal_data(t1, t2)
+
+    def test_simple_meta(self, tmpdir):
+        filename = str(tmpdir.join('test_simple.fits'))
+        t1 = Table(self.data)
+        t1.meta['A'] = 1
+        t1.meta['B'] = 2.3
+        t1.meta['C'] = 'spam'
+        t1.meta['comments'] = ['this', 'is', 'a', 'long', 'comment']
+        t1.meta['HISTORY'] = ['first', 'second', 'third']
+        t1.write(filename, overwrite=True)
+        t2 = Table.read(filename)
+        assert equal_data(t1, t2)
+        for key in t1.meta:
+            if isinstance(t1.meta, list):
+                for i in range(len(t1.meta[key])):
+                    assert t1.meta[key][i] == t2.meta[key][i]
+            else:
+                assert t1.meta[key] == t2.meta[key]
+
+    def test_simple_meta_conflicting(self, tmpdir):
+        filename = str(tmpdir.join('test_simple.fits'))
+        t1 = Table(self.data)
+        t1.meta['ttype1'] = 'spam'
+        with catch_warnings() as l:
+            t1.write(filename, overwrite=True)
+        assert len(l) == 1
+        assert str(l[0].message).startswith(
+            'Meta-data keyword ttype1 will be ignored since it conflicts with a FITS reserved keyword')
+
+    def test_simple_noextension(self, tmpdir):
+        """
+        Test that file type is recognized without extension
+        """
+        filename = str(tmpdir.join('test_simple'))
+        t1 = Table(self.data)
+        t1.write(filename, overwrite=True, format='fits')
+        t2 = Table.read(filename)
+        assert equal_data(t1, t2)
+
+    @pytest.mark.parametrize('table_type', (Table, QTable))
+    def test_with_units(self, table_type, tmpdir):
+        filename = str(tmpdir.join('test_with_units.fits'))
+        t1 = table_type(self.data)
+        t1['a'].unit = u.m
+        t1['c'].unit = u.km / u.s
+        t1.write(filename, overwrite=True)
+        t2 = table_type.read(filename)
+        assert equal_data(t1, t2)
+        assert t2['a'].unit == u.m
+        assert t2['c'].unit == u.km / u.s
+
+    @pytest.mark.parametrize('table_type', (Table, QTable))
+    def test_with_format(self, table_type, tmpdir):
+        filename = str(tmpdir.join('test_with_format.fits'))
+        t1 = table_type(self.data)
+        t1['a'].format = '{:5d}'
+        t1['b'].format = '{:>20}'
+        t1['c'].format = '{:6.2f}'
+        t1.write(filename, overwrite=True)
+        t2 = table_type.read(filename)
+        assert equal_data(t1, t2)
+        assert t2['a'].format == '{:5d}'
+        assert t2['b'].format == '{:>20}'
+        assert t2['c'].format == '{:6.2f}'
+
+    def test_masked(self, tmpdir):
+        filename = str(tmpdir.join('test_masked.fits'))
+        t1 = Table(self.data, masked=True)
+        t1.mask['a'] = [1, 0, 1, 0]
+        t1.mask['b'] = [1, 0, 0, 1]
+        t1.mask['c'] = [0, 1, 1, 0]
+        t1.write(filename, overwrite=True)
+        t2 = Table.read(filename)
+        assert t2.masked
+        assert equal_data(t1, t2)
+        assert np.all(t1['a'].mask == t2['a'].mask)
+        # Disabled for now, as there is no obvious way to handle masking of
+        # non-integer columns in FITS
+        # TODO: Re-enable these tests if some workaround for this can be found
+        # assert np.all(t1['b'].mask == t2['b'].mask)
+        # assert np.all(t1['c'].mask == t2['c'].mask)
+
+    def test_masked_nan(self, tmpdir):
+        filename = str(tmpdir.join('test_masked_nan.fits'))
+        data = np.array(list(zip([5.2, 8.4, 3.9, 6.3],
+                                 [2.3, 4.5, 6.7, 8.9])),
+                                dtype=[(str('a'), np.float64), (str('b'), np.float32)])
+        t1 = Table(data, masked=True)
+        t1.mask['a'] = [1, 0, 1, 0]
+        t1.mask['b'] = [1, 0, 0, 1]
+        t1.write(filename, overwrite=True)
+        t2 = Table.read(filename)
+        np.testing.assert_array_almost_equal(t2['a'], [np.nan, 8.4, np.nan, 6.3])
+        np.testing.assert_array_almost_equal(t2['b'], [np.nan, 4.5, 6.7, np.nan])
+        # assert t2.masked
+        # t2.masked = false currently, as the only way to determine whether a table is masked
+        # while reading is to check whether col.null is present. For float columns, col.null
+        # is not initialized
+
+    def test_read_from_fileobj(self, tmpdir):
+        filename = str(tmpdir.join('test_read_from_fileobj.fits'))
+        hdu = BinTableHDU(self.data)
+        hdu.writeto(filename, overwrite=True)
+        with open(filename, 'rb') as f:
+            t = Table.read(f)
+        assert equal_data(t, self.data)
+
+    def test_read_with_nonstandard_units(self):
+        hdu = BinTableHDU(self.data)
+        hdu.columns[0].unit = 'RADIANS'
+        hdu.columns[1].unit = 'spam'
+        hdu.columns[2].unit = 'millieggs'
+        t = Table.read(hdu)
+        assert equal_data(t, self.data)
+
+    def test_memmap(self, tmpdir):
+        filename = str(tmpdir.join('test_simple.fts'))
+        t1 = Table(self.data)
+        t1.write(filename, overwrite=True)
+        t2 = Table.read(filename, memmap=False)
+        t3 = Table.read(filename, memmap=True)
+        assert equal_data(t2, t3)
+        # To avoid issues with --open-files, we need to remove references to
+        # data that uses memory mapping and force the garbage collection
+        del t1, t2, t3
+        gc.collect()
+
+    @pytest.mark.parametrize('memmap', (False, True))
+    def test_character_as_bytes(self, tmpdir, memmap):
+        filename = str(tmpdir.join('test_simple.fts'))
+        t1 = Table(self.data)
+        t1.write(filename, overwrite=True)
+        t2 = Table.read(filename, character_as_bytes=False, memmap=memmap)
+        t3 = Table.read(filename, character_as_bytes=True, memmap=memmap)
+        assert t2['b'].dtype.kind == 'U'
+        assert t3['b'].dtype.kind == 'S'
+        assert equal_data(t2, t3)
+        # To avoid issues with --open-files, we need to remove references to
+        # data that uses memory mapping and force the garbage collection
+        del t1, t2, t3
+        gc.collect()
+
+
+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)
+
+
+def test_masking_regression_1795():
+    """
+    Regression test for #1795 - this bug originally caused columns where TNULL
+    was not defined to have their first element masked.
+    """
+    t = Table.read(os.path.join(DATA, 'tb.fits'))
+    assert np.all(t['c1'].mask == np.array([False, False]))
+    assert np.all(t['c2'].mask == np.array([False, False]))
+    assert np.all(t['c3'].mask == np.array([False, False]))
+    assert np.all(t['c4'].mask == np.array([False, False]))
+    assert np.all(t['c1'].data == np.array([1, 2]))
+    assert np.all(t['c2'].data == np.array([b'abc', b'xy ']))
+    assert_allclose(t['c3'].data, np.array([3.70000007153, 6.6999997139]))
+    assert np.all(t['c4'].data == np.array([False, True]))
+
+
+def test_scale_error():
+    a = [1, 4, 5]
+    b = [2.0, 5.0, 8.2]
+    c = ['x', 'y', 'z']
+    t = Table([a, b, c], names=('a', 'b', 'c'), meta={'name': 'first table'})
+    t['a'].unit = '1.2'
+    with pytest.raises(UnitScaleError) as exc:
+        t.write('t.fits', format='fits', overwrite=True)
+    assert exc.value.args[0] == "The column 'a' could not be stored in FITS format because it has a scale '(1.2)' that is not recognized by the FITS standard. Either scale the data or change the units."
+
+
+@pytest.mark.parametrize('tdisp_str, format_return',
+                         [('EN10.5', ('EN', '10', '5', None)),
+                          ('F6.2', ('F', '6', '2', None)),
+                          ('B5.10', ('B', '5', '10', None)),
+                          ('E10.5E3', ('E', '10', '5', '3')),
+                          ('A21', ('A', '21', None, None))])
+def test_parse_tdisp_format(tdisp_str, format_return):
+    assert _parse_tdisp_format(tdisp_str) == format_return
+
+
+@pytest.mark.parametrize('tdisp_str, format_str_return',
+                         [('G15.4E2', '{:15.4g}'),
+                          ('Z5.10', '{:5x}'),
+                          ('I6.5', '{:6d}'),
+                          ('L8', '{:>8}'),
+                          ('E20.7', '{:20.7e}')])
+def test_fortran_to_python_format(tdisp_str, format_str_return):
+    assert _fortran_to_python_format(tdisp_str) == format_str_return
+
+
+@pytest.mark.parametrize('fmt_str, tdisp_str',
+                         [('{:3d}', 'I3'),
+                          ('3d', 'I3'),
+                          ('7.3f', 'F7.3'),
+                          ('{:>4}', 'A4'),
+                          ('{:7.4f}', 'F7.4'),
+                          ('%5.3g', 'G5.3'),
+                          ('%10s', 'A10'),
+                          ('%.4f', 'F13.4')])
+def test_python_to_tdisp(fmt_str, tdisp_str):
+    assert python_to_tdisp(fmt_str) == tdisp_str
+
+
+def test_logical_python_to_tdisp():
+    assert python_to_tdisp('{:>7}', logical_dtype=True) == 'L7'
+
+
+def test_bool_column(tmpdir):
+    """
+    Regression test for https://github.com/astropy/astropy/issues/1953
+
+    Ensures that Table columns of bools are properly written to a FITS table.
+    """
+
+    arr = np.ones(5, dtype=bool)
+    arr[::2] == np.False_
+
+    t = Table([arr])
+    t.write(str(tmpdir.join('test.fits')), overwrite=True)
+
+    with fits.open(str(tmpdir.join('test.fits'))) as hdul:
+        assert hdul[1].data['col0'].dtype == np.dtype('bool')
+        assert np.all(hdul[1].data['col0'] == arr)
+
+
+def test_unicode_column(tmpdir):
+    """
+    Test that a column of unicode strings is still written as one
+    byte-per-character in the FITS table (so long as the column can be ASCII
+    encoded).
+
+    Regression test for one of the issues fixed in
+    https://github.com/astropy/astropy/pull/4228
+    """
+
+    t = Table([np.array([u'a', u'b', u'cd'])])
+    t.write(str(tmpdir.join('test.fits')), overwrite=True)
+
+    with fits.open(str(tmpdir.join('test.fits'))) as hdul:
+        assert np.all(hdul[1].data['col0'] == ['a', 'b', 'cd'])
+        assert hdul[1].header['TFORM1'] == '2A'
+
+    t2 = Table([np.array([u'\N{SNOWMAN}'])])
+
+    with pytest.raises(UnicodeEncodeError):
+        t2.write(str(tmpdir.join('test.fits')), overwrite=True)
+
+
+def test_unit_warnings_read_write(tmpdir):
+    filename = str(tmpdir.join('test_unit.fits'))
+    t1 = Table([[1, 2], [3, 4]], names=['a', 'b'])
+    t1['a'].unit = 'm/s'
+    t1['b'].unit = 'not-a-unit'
+
+    with catch_warnings() as l:
+        t1.write(filename, overwrite=True)
+        assert len(l) == 1
+        assert str(l[0].message).startswith("'not-a-unit' did not parse as fits unit")
+
+    with catch_warnings() as l:
+        Table.read(filename, hdu=1)
+    assert len(l) == 0
+
+
+def test_convert_comment_convention(tmpdir):
+    """
+    Regression test for https://github.com/astropy/astropy/issues/6079
+    """
+    filename = os.path.join(DATA, 'stddata.fits')
+    with pytest.warns(AstropyUserWarning, match='hdu= was not specified but '
+                      'multiple tables are present'):
+        t = Table.read(filename)
+
+    assert t.meta['comments'] == [
+        '',
+        ' *** End of mandatory fields ***',
+        '',
+        '',
+        ' *** Column names ***',
+        '',
+        '',
+        ' *** Column formats ***',
+        ''
+    ]
+
+
+def assert_objects_equal(obj1, obj2, attrs, compare_class=True):
+    if compare_class:
+        assert obj1.__class__ is obj2.__class__
+
+    info_attrs = ['info.name', 'info.format', 'info.unit', 'info.description', 'info.meta']
+    for attr in attrs + info_attrs:
+        a1 = obj1
+        a2 = obj2
+        for subattr in attr.split('.'):
+            try:
+                a1 = getattr(a1, subattr)
+                a2 = getattr(a2, subattr)
+            except AttributeError:
+                a1 = a1[subattr]
+                a2 = a2[subattr]
+
+        # Mixin info.meta can None instead of empty OrderedDict(), #6720 would
+        # fix this.
+        if attr == 'info.meta':
+            if a1 is None:
+                a1 = {}
+            if a2 is None:
+                a2 = {}
+
+        assert np.all(a1 == a2)
+
+# Testing FITS table read/write with mixins.  This is mostly
+# copied from ECSV mixin testing.
+
+el = EarthLocation(x=1 * u.km, y=3 * u.km, z=5 * u.km)
+el2 = EarthLocation(x=[1, 2] * u.km, y=[3, 4] * u.km, z=[5, 6] * u.km)
+sc = SkyCoord([1, 2], [3, 4], unit='deg,deg', frame='fk4',
+              obstime='J1990.5')
+scc = sc.copy()
+scc.representation_type = 'cartesian'
+tm = Time([2450814.5, 2450815.5], format='jd', scale='tai', location=el)
+
+
+mixin_cols = {
+    'tm': tm,
+    'dt': TimeDelta([1, 2] * u.day),
+    'sc': sc,
+    'scc': scc,
+    'scd': SkyCoord([1, 2], [3, 4], [5, 6], unit='deg,deg,m', frame='fk4',
+                    obstime=['J1990.5', 'J1991.5']),
+    'q': [1, 2] * u.m,
+    'lat': Latitude([1, 2] * u.deg),
+    'lon': Longitude([1, 2] * u.deg, wrap_angle=180. * u.deg),
+    'ang': Angle([1, 2] * u.deg),
+    'el2': el2,
+}
+
+time_attrs = ['value', 'shape', 'format', 'scale', 'location']
+compare_attrs = {
+    'c1': ['data'],
+    'c2': ['data'],
+    'tm': time_attrs,
+    'dt': ['shape', 'value', 'format', 'scale'],
+    'sc': ['ra', 'dec', 'representation_type', 'frame.name'],
+    'scc': ['x', 'y', 'z', 'representation_type', 'frame.name'],
+    'scd': ['ra', 'dec', 'distance', 'representation_type', 'frame.name'],
+    'q': ['value', 'unit'],
+    'lon': ['value', 'unit', 'wrap_angle'],
+    'lat': ['value', 'unit'],
+    'ang': ['value', 'unit'],
+    'el2': ['x', 'y', 'z', 'ellipsoid'],
+    'nd': ['x', 'y', 'z'],
+}
+
+
+@pytest.mark.skipif('not HAS_YAML')
+def test_fits_mixins_qtable_to_table(tmpdir):
+    """Test writing as QTable and reading as Table.  Ensure correct classes
+    come out.
+    """
+    filename = str(tmpdir.join('test_simple.fits'))
+
+    names = sorted(mixin_cols)
+
+    t = QTable([mixin_cols[name] for name in names], names=names)
+    t.write(filename, format='fits')
+    t2 = Table.read(filename, format='fits', astropy_native=True)
+
+    assert t.colnames == t2.colnames
+
+    for name, col in t.columns.items():
+        col2 = t2[name]
+
+        # Special-case Time, which does not yet support round-tripping
+        # the format.
+        if isinstance(col2, Time):
+            col2.format = col.format
+
+        attrs = compare_attrs[name]
+        compare_class = True
+
+        if isinstance(col.info, QuantityInfo):
+            # Downgrade Quantity to Column + unit
+            assert type(col2) is Column
+            # Class-specific attributes like `value` or `wrap_angle` are lost.
+            attrs = ['unit']
+            compare_class = False
+            # Compare data values here (assert_objects_equal doesn't know how in this case)
+            assert np.all(col.value == col2)
+
+        assert_objects_equal(col, col2, attrs, compare_class)
+
+
+@pytest.mark.skipif('not HAS_YAML')
+@pytest.mark.parametrize('table_cls', (Table, QTable))
+def test_fits_mixins_as_one(table_cls, tmpdir):
+    """Test write/read all cols at once and validate intermediate column names"""
+    filename = str(tmpdir.join('test_simple.fits'))
+    names = sorted(mixin_cols)
+
+    serialized_names = ['ang',
+                        'dt.jd1', 'dt.jd2',
+                        'el2.x', 'el2.y', 'el2.z',
+                        'lat',
+                        'lon',
+                        'q',
+                        'sc.ra', 'sc.dec',
+                        'scc.x', 'scc.y', 'scc.z',
+                        'scd.ra', 'scd.dec', 'scd.distance',
+                        'scd.obstime.jd1', 'scd.obstime.jd2',
+                        'tm',  # serialize_method is formatted_value
+                        ]
+
+    t = table_cls([mixin_cols[name] for name in names], names=names)
+    t.meta['C'] = 'spam'
+    t.meta['comments'] = ['this', 'is', 'a', 'comment']
+    t.meta['history'] = ['first', 'second', 'third']
+
+    t.write(filename, format="fits")
+
+    t2 = table_cls.read(filename, format='fits', astropy_native=True)
+    assert t2.meta['C'] == 'spam'
+    assert t2.meta['comments'] == ['this', 'is', 'a', 'comment']
+    assert t2.meta['HISTORY'] == ['first', 'second', 'third']
+
+    assert t.colnames == t2.colnames
+
+    # Read directly via fits and confirm column names
+    with fits.open(filename) as hdus:
+        assert hdus[1].columns.names == serialized_names
+
+
+@pytest.mark.skipif('not HAS_YAML')
+@pytest.mark.parametrize('name_col', list(mixin_cols.items()))
+@pytest.mark.parametrize('table_cls', (Table, QTable))
+def test_fits_mixins_per_column(table_cls, name_col, tmpdir):
+    """Test write/read one col at a time and do detailed validation"""
+    filename = str(tmpdir.join('test_simple.fits'))
+    name, col = name_col
+
+    c = [1.0, 2.0]
+    t = table_cls([c, col, c], names=['c1', name, 'c2'])
+    t[name].info.description = 'my \n\n\n description'
+    t[name].info.meta = {'list': list(range(50)), 'dict': {'a': 'b' * 200}}
+
+    if not t.has_mixin_columns:
+        pytest.skip('column is not a mixin (e.g. Quantity subclass in Table)')
+
+    if isinstance(t[name], NdarrayMixin):
+        pytest.xfail('NdarrayMixin not supported')
+
+    t.write(filename, format="fits")
+    t2 = table_cls.read(filename, format='fits', astropy_native=True)
+
+    assert t.colnames == t2.colnames
+
+    for colname in t.colnames:
+        assert_objects_equal(t[colname], t2[colname], compare_attrs[colname])
+
+    # Special case to make sure Column type doesn't leak into Time class data
+    if name.startswith('tm'):
+        assert t2[name]._time.jd1.__class__ is np.ndarray
+        assert t2[name]._time.jd2.__class__ is np.ndarray
+
+
+@pytest.mark.skipif('HAS_YAML')
+def test_warn_for_dropped_info_attributes(tmpdir):
+    filename = str(tmpdir.join('test.fits'))
+    t = Table([[1, 2]])
+    t['col0'].info.description = 'hello'
+    with catch_warnings() as warns:
+        t.write(filename, overwrite=True)
+    assert len(warns) == 1
+    assert str(warns[0].message).startswith(
+        "table contains column(s) with defined 'format'")
+
+
+@pytest.mark.skipif('HAS_YAML')
+def test_error_for_mixins_but_no_yaml(tmpdir):
+    filename = str(tmpdir.join('test.fits'))
+    t = Table([mixin_cols['sc']])
+    with pytest.raises(TypeError) as err:
+        t.write(filename)
+    assert "cannot write type SkyCoord column 'col0' to FITS without PyYAML" in str(err)
+
+
+@pytest.mark.skipif('not HAS_YAML')
+def test_info_attributes_with_no_mixins(tmpdir):
+    """Even if there are no mixin columns, if there is metadata that would be lost it still
+    gets serialized
+    """
+    filename = str(tmpdir.join('test.fits'))
+    t = Table([[1.0, 2.0]])
+    t['col0'].description = 'hello' * 40
+    t['col0'].format = '{:8.4f}'
+    t['col0'].meta['a'] = {'b': 'c'}
+    t.write(filename, overwrite=True)
+
+    t2 = Table.read(filename)
+    assert t2['col0'].description == 'hello' * 40
+    assert t2['col0'].format == '{:8.4f}'
+    assert t2['col0'].meta['a'] == {'b': 'c'}
+
+
+@pytest.mark.skipif('not HAS_YAML')
+@pytest.mark.parametrize('method', ['set_cols', 'names', 'class'])
+def test_round_trip_masked_table_serialize_mask(tmpdir, method):
+    """
+    Same as previous test but set the serialize_method to 'data_mask' so mask is
+    written out and the behavior is all correct.
+    """
+    filename = str(tmpdir.join('test.fits'))
+
+    t = simple_table(masked=True)  # int, float, and str cols with one masked element
+
+    # MaskedColumn but no masked elements.  See table the MaskedColumnInfo class
+    # _represent_as_dict() method for info about we test a column with no masked elements.
+    t['d'] = [1, 2, 3]
+
+    if method == 'set_cols':
+        for col in t.itercols():
+            col.info.serialize_method['fits'] = 'data_mask'
+        t.write(filename)
+    elif method == 'names':
+        t.write(filename, serialize_method={'a': 'data_mask', 'b': 'data_mask',
+                                            'c': 'data_mask', 'd': 'data_mask'})
+    elif method == 'class':
+        t.write(filename, serialize_method='data_mask')
+
+    t2 = Table.read(filename)
+    assert t2.masked is True
+    assert t2.colnames == t.colnames
+    for name in t2.colnames:
+        assert np.all(t2[name].mask == t[name].mask)
+        assert np.all(t2[name] == t[name])
+
+        # Data under the mask round-trips also (unmask data to show this).
+        t[name].mask = False
+        t2[name].mask = False
+        assert np.all(t2[name] == t[name])

testbed/astropy__astropy/astropy/io/fits/tests/test_convenience.py

@@ -0,0 +1,203 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+
+import os
+import warnings
+
+import pytest
+import numpy as np
+
+from astropy.io import fits
+from astropy.table import Table
+from astropy.io.fits import printdiff
+from astropy.tests.helper import catch_warnings
+
+from . import FitsTestCase
+
+
+class TestConvenience(FitsTestCase):
+
+    def test_resource_warning(self):
+        warnings.simplefilter('always', ResourceWarning)
+        with catch_warnings() as w:
+            data = fits.getdata(self.data('test0.fits'))
+            assert len(w) == 0
+
+        with catch_warnings() as w:
+            header = fits.getheader(self.data('test0.fits'))
+            assert len(w) == 0
+
+    def test_fileobj_not_closed(self):
+        """
+        Tests that file-like objects are not closed after being passed
+        to convenience functions.
+
+        Regression test for https://github.com/astropy/astropy/issues/5063
+        """
+
+        f = open(self.data('test0.fits'), 'rb')
+        data = fits.getdata(f)
+        assert not f.closed
+
+        f.seek(0)
+        header = fits.getheader(f)
+        assert not f.closed
+
+        f.close()  # Close it now
+
+    def test_table_to_hdu(self):
+        table = Table([[1, 2, 3], ['a', 'b', 'c'], [2.3, 4.5, 6.7]],
+                      names=['a', 'b', 'c'], dtype=['i', 'U1', 'f'])
+        table['a'].unit = 'm/s'
+        table['b'].unit = 'not-a-unit'
+
+        with catch_warnings() as w:
+            hdu = fits.table_to_hdu(table)
+            assert len(w) == 1
+            assert str(w[0].message).startswith("'not-a-unit' did not parse as"
+                                                " fits unit")
+
+        # Check that TUNITn cards appear in the correct order
+        # (https://github.com/astropy/astropy/pull/5720)
+        assert hdu.header.index('TUNIT1') < hdu.header.index('TTYPE2')
+
+        assert isinstance(hdu, fits.BinTableHDU)
+        filename = self.temp('test_table_to_hdu.fits')
+        hdu.writeto(filename, overwrite=True)
+
+    def test_table_to_hdu_convert_comment_convention(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/6079
+        """
+        table = Table([[1, 2, 3], ['a', 'b', 'c'], [2.3, 4.5, 6.7]],
+                      names=['a', 'b', 'c'], dtype=['i', 'U1', 'f'])
+        table.meta['comments'] = ['This', 'is', 'a', 'comment']
+        hdu = fits.table_to_hdu(table)
+
+        assert hdu.header.get('comment') == ['This', 'is', 'a', 'comment']
+        with pytest.raises(ValueError):
+            hdu.header.index('comments')
+
+    def test_table_writeto_header(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/5988
+        """
+        data = np.zeros((5, ), dtype=[('x', float), ('y', int)])
+        h_in = fits.Header()
+        h_in['ANSWER'] = (42.0, 'LTU&E')
+        filename = self.temp('tabhdr42.fits')
+        fits.writeto(filename, data=data, header=h_in, overwrite=True)
+        h_out = fits.getheader(filename, ext=1)
+        assert h_out['ANSWER'] == 42
+
+    def test_image_extension_update_header(self):
+        """
+        Test that _makehdu correctly includes the header. For example in the
+        fits.update convenience function.
+        """
+        filename = self.temp('twoextension.fits')
+
+        hdus = [fits.PrimaryHDU(np.zeros((10, 10))),
+                fits.ImageHDU(np.zeros((10, 10)))]
+
+        fits.HDUList(hdus).writeto(filename)
+
+        fits.update(filename,
+                    np.zeros((10, 10)),
+                    header=fits.Header([('WHAT', 100)]),
+                    ext=1)
+        h_out = fits.getheader(filename, ext=1)
+        assert h_out['WHAT'] == 100
+
+    def test_printdiff(self):
+        """
+        Test that FITSDiff can run the different inputs without crashing.
+        """
+
+        # Testing different string input options
+        assert printdiff(self.data('arange.fits'),
+                         self.data('blank.fits')) is None
+        assert printdiff(self.data('arange.fits'),
+                         self.data('blank.fits'), ext=0) is None
+        assert printdiff(self.data('o4sp040b0_raw.fits'),
+                         self.data('o4sp040b0_raw.fits'),
+                         extname='sci') is None
+
+        # This may seem weird, but check printdiff to see, need to test
+        # incorrect second file
+        with pytest.raises(OSError):
+            printdiff('o4sp040b0_raw.fits', 'fakefile.fits', extname='sci')
+
+        # Test HDU object inputs
+        with fits.open(self.data('stddata.fits'), mode='readonly') as in1:
+            with fits.open(self.data('checksum.fits'), mode='readonly') as in2:
+
+                assert printdiff(in1[0], in2[0]) is None
+
+                with pytest.raises(ValueError):
+                    printdiff(in1[0], in2[0], ext=0)
+
+                assert printdiff(in1, in2) is None
+
+                with pytest.raises(NotImplementedError):
+                    printdiff(in1, in2, 0)
+
+    def test_tabledump(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/6937
+        """
+        # copy fits file to the temp directory
+        self.copy_file('tb.fits')
+
+        # test without datafile
+        fits.tabledump(self.temp('tb.fits'))
+        assert os.path.isfile(self.temp('tb_1.txt'))
+
+        # test with datafile
+        fits.tabledump(self.temp('tb.fits'), datafile=self.temp('test_tb.txt'))
+        assert os.path.isfile(self.temp('test_tb.txt'))
+
+    def test_append_filename(self):
+        """
+        Test fits.append with a filename argument.
+        """
+        data = np.arange(6)
+        testfile = self.temp('test_append_1.fits')
+
+        # Test case 1: creation of file
+        fits.append(testfile, data=data, checksum=True)
+
+        # Test case 2: append to existing file, with verify=True
+        # Also test that additional keyword can be passed to fitsopen
+        fits.append(testfile, data=data * 2, checksum=True, ignore_blank=True)
+
+        # Test case 3: append to existing file, with verify=False
+        fits.append(testfile, data=data * 3, checksum=True, verify=False)
+
+        with fits.open(testfile, checksum=True) as hdu1:
+            np.testing.assert_array_equal(hdu1[0].data, data)
+            np.testing.assert_array_equal(hdu1[1].data, data * 2)
+            np.testing.assert_array_equal(hdu1[2].data, data * 3)
+
+    @pytest.mark.parametrize('mode', ['wb', 'wb+', 'ab', 'ab+'])
+    def test_append_filehandle(self, tmpdir, mode):
+        """
+        Test fits.append with a file handle argument.
+        """
+        append_file = tmpdir.join('append.fits')
+        with append_file.open(mode) as handle:
+            fits.append(filename=handle, data=np.ones((4, 4)))
+
+    def test_append_with_header(self):
+        """
+        Test fits.append with a fits Header, which triggers detection of the
+        HDU class. Regression test for
+        https://github.com/astropy/astropy/issues/8660
+        """
+        testfile = self.temp('test_append_1.fits')
+        with fits.open(self.data('test0.fits')) as hdus:
+            for hdu in hdus:
+                fits.append(testfile, hdu.data, hdu.header, checksum=True)
+
+        with fits.open(testfile, checksum=True) as hdus:
+            assert len(hdus) == 5

testbed/astropy__astropy/astropy/io/fits/tests/test_core.py

@@ -0,0 +1,1389 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import gzip
+import bz2
+import io
+import mmap
+import errno
+import os
+import pathlib
+import warnings
+import zipfile
+from unittest.mock import patch
+
+import pytest
+import numpy as np
+
+from . import FitsTestCase
+
+from astropy.io.fits.convenience import _getext
+from astropy.io.fits.diff import FITSDiff
+from astropy.io.fits.file import _File, GZIP_MAGIC
+
+from astropy.io import fits
+from astropy.tests.helper import raises, catch_warnings, ignore_warnings
+from astropy.utils.data import conf, get_pkg_data_filename
+from astropy.utils.exceptions import AstropyUserWarning
+from astropy.utils import data
+
+
+class TestCore(FitsTestCase):
+
+    @raises(OSError)
+    def test_missing_file(self):
+        fits.open(self.temp('does-not-exist.fits'))
+
+    def test_filename_is_bytes_object(self):
+        with pytest.raises(TypeError):
+            fits.open(self.data('ascii.fits').encode())
+
+    def test_naxisj_check(self):
+        with fits.open(self.data('o4sp040b0_raw.fits')) as hdulist:
+            hdulist[1].header['NAXIS3'] = 500
+
+            assert 'NAXIS3' in hdulist[1].header
+            hdulist.verify('silentfix')
+            assert 'NAXIS3' not in hdulist[1].header
+
+    def test_byteswap(self):
+        p = fits.PrimaryHDU()
+        l = fits.HDUList()
+
+        n = np.zeros(3, dtype='i2')
+        n[0] = 1
+        n[1] = 60000
+        n[2] = 2
+
+        c = fits.Column(name='foo', format='i2', bscale=1, bzero=32768,
+                        array=n)
+        t = fits.BinTableHDU.from_columns([c])
+
+        l.append(p)
+        l.append(t)
+
+        l.writeto(self.temp('test.fits'), overwrite=True)
+
+        with fits.open(self.temp('test.fits')) as p:
+            assert p[1].data[1]['foo'] == 60000.0
+
+    def test_fits_file_path_object(self):
+        """
+        Testing when fits file is passed as pathlib.Path object #4412.
+        """
+        fpath = pathlib.Path(get_pkg_data_filename('data/tdim.fits'))
+        with fits.open(fpath) as hdulist:
+            assert hdulist[0].filebytes() == 2880
+            assert hdulist[1].filebytes() == 5760
+
+            with fits.open(self.data('tdim.fits')) as hdulist2:
+                assert FITSDiff(hdulist2, hdulist).identical is True
+
+    def test_add_del_columns(self):
+        p = fits.ColDefs([])
+        p.add_col(fits.Column(name='FOO', format='3J'))
+        p.add_col(fits.Column(name='BAR', format='1I'))
+        assert p.names == ['FOO', 'BAR']
+        p.del_col('FOO')
+        assert p.names == ['BAR']
+
+    def test_add_del_columns2(self):
+        hdulist = fits.open(self.data('tb.fits'))
+        table = hdulist[1]
+        assert table.data.dtype.names == ('c1', 'c2', 'c3', 'c4')
+        assert table.columns.names == ['c1', 'c2', 'c3', 'c4']
+        table.columns.del_col(str('c1'))
+        assert table.data.dtype.names == ('c2', 'c3', 'c4')
+        assert table.columns.names == ['c2', 'c3', 'c4']
+
+        table.columns.del_col(str('c3'))
+        assert table.data.dtype.names == ('c2', 'c4')
+        assert table.columns.names == ['c2', 'c4']
+
+        table.columns.add_col(fits.Column(str('foo'), str('3J')))
+        assert table.data.dtype.names == ('c2', 'c4', 'foo')
+        assert table.columns.names == ['c2', 'c4', 'foo']
+
+        hdulist.writeto(self.temp('test.fits'), overwrite=True)
+        with ignore_warnings():
+            # TODO: The warning raised by this test is actually indication of a
+            # bug and should *not* be ignored. But as it is a known issue we
+            # hide it for now.  See
+            # https://github.com/spacetelescope/PyFITS/issues/44
+            with fits.open(self.temp('test.fits')) as hdulist:
+                table = hdulist[1]
+                assert table.data.dtype.names == ('c2', 'c4', 'foo')
+                assert table.columns.names == ['c2', 'c4', 'foo']
+
+    def test_update_header_card(self):
+        """A very basic test for the Header.update method--I'd like to add a
+        few more cases to this at some point.
+        """
+
+        header = fits.Header()
+        comment = 'number of bits per data pixel'
+        header['BITPIX'] = (16, comment)
+        assert 'BITPIX' in header
+        assert header['BITPIX'] == 16
+        assert header.comments['BITPIX'] == comment
+
+        header.update(BITPIX=32)
+        assert header['BITPIX'] == 32
+        assert header.comments['BITPIX'] == ''
+
+    def test_set_card_value(self):
+        """Similar to test_update_header_card(), but tests the the
+        `header['FOO'] = 'bar'` method of updating card values.
+        """
+
+        header = fits.Header()
+        comment = 'number of bits per data pixel'
+        card = fits.Card.fromstring('BITPIX  = 32 / {}'.format(comment))
+        header.append(card)
+
+        header['BITPIX'] = 32
+
+        assert 'BITPIX' in header
+        assert header['BITPIX'] == 32
+        assert header.cards[0].keyword == 'BITPIX'
+        assert header.cards[0].value == 32
+        assert header.cards[0].comment == comment
+
+    def test_uint(self):
+        filename = self.data('o4sp040b0_raw.fits')
+        with fits.open(filename, uint=False) as hdulist_f:
+            with fits.open(filename, uint=True) as hdulist_i:
+                assert hdulist_f[1].data.dtype == np.float32
+                assert hdulist_i[1].data.dtype == np.uint16
+                assert np.all(hdulist_f[1].data == hdulist_i[1].data)
+
+    def test_fix_missing_card_append(self):
+        hdu = fits.ImageHDU()
+        errs = hdu.req_cards('TESTKW', None, None, 'foo', 'silentfix', [])
+        assert len(errs) == 1
+        assert 'TESTKW' in hdu.header
+        assert hdu.header['TESTKW'] == 'foo'
+        assert hdu.header.cards[-1].keyword == 'TESTKW'
+
+    def test_fix_invalid_keyword_value(self):
+        hdu = fits.ImageHDU()
+        hdu.header['TESTKW'] = 'foo'
+        errs = hdu.req_cards('TESTKW', None,
+                             lambda v: v == 'foo', 'foo', 'ignore', [])
+        assert len(errs) == 0
+
+        # Now try a test that will fail, and ensure that an error will be
+        # raised in 'exception' mode
+        errs = hdu.req_cards('TESTKW', None, lambda v: v == 'bar', 'bar',
+                             'exception', [])
+        assert len(errs) == 1
+        assert errs[0][1] == "'TESTKW' card has invalid value 'foo'."
+
+        # See if fixing will work
+        hdu.req_cards('TESTKW', None, lambda v: v == 'bar', 'bar', 'silentfix',
+                      [])
+        assert hdu.header['TESTKW'] == 'bar'
+
+    @raises(fits.VerifyError)
+    def test_unfixable_missing_card(self):
+        class TestHDU(fits.hdu.base.NonstandardExtHDU):
+            def _verify(self, option='warn'):
+                errs = super()._verify(option)
+                hdu.req_cards('TESTKW', None, None, None, 'fix', errs)
+                return errs
+
+            @classmethod
+            def match_header(cls, header):
+                # Since creating this HDU class adds it to the registry we
+                # don't want the file reader to possibly think any actual
+                # HDU from a file should be handled by this class
+                return False
+
+        hdu = TestHDU(header=fits.Header())
+        hdu.verify('fix')
+
+    @raises(fits.VerifyError)
+    def test_exception_on_verification_error(self):
+        hdu = fits.ImageHDU()
+        del hdu.header['XTENSION']
+        hdu.verify('exception')
+
+    def test_ignore_verification_error(self):
+        hdu = fits.ImageHDU()
+        # The default here would be to issue a warning; ensure that no warnings
+        # or exceptions are raised
+        with catch_warnings():
+            warnings.simplefilter('error')
+            del hdu.header['NAXIS']
+            try:
+                hdu.verify('ignore')
+            except Exception as exc:
+                self.fail('An exception occurred when the verification error '
+                          'should have been ignored: {}'.format(exc))
+        # Make sure the error wasn't fixed either, silently or otherwise
+        assert 'NAXIS' not in hdu.header
+
+    @raises(ValueError)
+    def test_unrecognized_verify_option(self):
+        hdu = fits.ImageHDU()
+        hdu.verify('foobarbaz')
+
+    def test_errlist_basic(self):
+        # Just some tests to make sure that _ErrList is setup correctly.
+        # No arguments
+        error_list = fits.verify._ErrList()
+        assert error_list == []
+        # Some contents - this is not actually working, it just makes sure they
+        # are kept.
+        error_list = fits.verify._ErrList([1, 2, 3])
+        assert error_list == [1, 2, 3]
+
+    def test_combined_verify_options(self):
+        """
+        Test verify options like fix+ignore.
+        """
+
+        def make_invalid_hdu():
+            hdu = fits.ImageHDU()
+            # Add one keyword to the header that contains a fixable defect, and one
+            # with an unfixable defect
+            c1 = fits.Card.fromstring("test    = '    test'")
+            c2 = fits.Card.fromstring("P.I.    = '  Hubble'")
+            hdu.header.append(c1)
+            hdu.header.append(c2)
+            return hdu
+
+        # silentfix+ignore should be completely silent
+        hdu = make_invalid_hdu()
+        with catch_warnings():
+            warnings.simplefilter('error')
+            try:
+                hdu.verify('silentfix+ignore')
+            except Exception as exc:
+                self.fail('An exception occurred when the verification error '
+                          'should have been ignored: {}'.format(exc))
+
+        # silentfix+warn should be quiet about the fixed HDU and only warn
+        # about the unfixable one
+        hdu = make_invalid_hdu()
+        with catch_warnings() as w:
+            hdu.verify('silentfix+warn')
+            assert len(w) == 4
+            assert 'Illegal keyword name' in str(w[2].message)
+
+        # silentfix+exception should only mention the unfixable error in the
+        # exception
+        hdu = make_invalid_hdu()
+        try:
+            hdu.verify('silentfix+exception')
+        except fits.VerifyError as exc:
+            assert 'Illegal keyword name' in str(exc)
+            assert 'not upper case' not in str(exc)
+        else:
+            self.fail('An exception should have been raised.')
+
+        # fix+ignore is not too useful, but it should warn about the fixed
+        # problems while saying nothing about the unfixable problems
+        hdu = make_invalid_hdu()
+        with catch_warnings() as w:
+            hdu.verify('fix+ignore')
+            assert len(w) == 4
+            assert 'not upper case' in str(w[2].message)
+
+        # fix+warn
+        hdu = make_invalid_hdu()
+        with catch_warnings() as w:
+            hdu.verify('fix+warn')
+            assert len(w) == 6
+            assert 'not upper case' in str(w[2].message)
+            assert 'Illegal keyword name' in str(w[4].message)
+
+        # fix+exception
+        hdu = make_invalid_hdu()
+        try:
+            hdu.verify('fix+exception')
+        except fits.VerifyError as exc:
+            assert 'Illegal keyword name' in str(exc)
+            assert 'not upper case' in str(exc)
+        else:
+            self.fail('An exception should have been raised.')
+
+    def test_getext(self):
+        """
+        Test the various different ways of specifying an extension header in
+        the convenience functions.
+        """
+        filename = self.data('test0.fits')
+
+        hl, ext = _getext(filename, 'readonly', 1)
+        assert ext == 1
+        hl.close()
+
+        pytest.raises(ValueError, _getext, filename, 'readonly',
+                      1, 2)
+        pytest.raises(ValueError, _getext, filename, 'readonly',
+                      (1, 2))
+        pytest.raises(ValueError, _getext, filename, 'readonly',
+                      'sci', 'sci')
+        pytest.raises(TypeError, _getext, filename, 'readonly',
+                      1, 2, 3)
+
+        hl, ext = _getext(filename, 'readonly', ext=1)
+        assert ext == 1
+        hl.close()
+
+        hl, ext = _getext(filename, 'readonly', ext=('sci', 2))
+        assert ext == ('sci', 2)
+        hl.close()
+
+        pytest.raises(TypeError, _getext, filename, 'readonly',
+                      1, ext=('sci', 2), extver=3)
+        pytest.raises(TypeError, _getext, filename, 'readonly',
+                      ext=('sci', 2), extver=3)
+
+        hl, ext = _getext(filename, 'readonly', 'sci')
+        assert ext == ('sci', 1)
+        hl.close()
+
+        hl, ext = _getext(filename, 'readonly', 'sci', 1)
+        assert ext == ('sci', 1)
+        hl.close()
+
+        hl, ext = _getext(filename, 'readonly', ('sci', 1))
+        assert ext == ('sci', 1)
+        hl.close()
+
+        hl, ext = _getext(filename, 'readonly', 'sci',
+                          extver=1, do_not_scale_image_data=True)
+        assert ext == ('sci', 1)
+        hl.close()
+
+        pytest.raises(TypeError, _getext, filename, 'readonly',
+                      'sci', ext=1)
+        pytest.raises(TypeError, _getext, filename, 'readonly',
+                      'sci', 1, extver=2)
+
+        hl, ext = _getext(filename, 'readonly', extname='sci')
+        assert ext == ('sci', 1)
+        hl.close()
+
+        hl, ext = _getext(filename, 'readonly', extname='sci',
+                          extver=1)
+        assert ext == ('sci', 1)
+        hl.close()
+
+        pytest.raises(TypeError, _getext, filename, 'readonly',
+                      extver=1)
+
+    def test_extension_name_case_sensitive(self):
+        """
+        Tests that setting fits.conf.extension_name_case_sensitive at
+        runtime works.
+        """
+
+        hdu = fits.ImageHDU()
+        hdu.name = 'sCi'
+        assert hdu.name == 'SCI'
+        assert hdu.header['EXTNAME'] == 'SCI'
+
+        with fits.conf.set_temp('extension_name_case_sensitive', True):
+            hdu = fits.ImageHDU()
+            hdu.name = 'sCi'
+            assert hdu.name == 'sCi'
+            assert hdu.header['EXTNAME'] == 'sCi'
+
+        hdu.name = 'sCi'
+        assert hdu.name == 'SCI'
+        assert hdu.header['EXTNAME'] == 'SCI'
+
+    def test_hdu_fromstring(self):
+        """
+        Tests creating a fully-formed HDU object from a string containing the
+        bytes of the HDU.
+        """
+        infile = self.data('test0.fits')
+        outfile = self.temp('test.fits')
+
+        with open(infile, 'rb') as fin:
+            dat = fin.read()
+
+        offset = 0
+        with fits.open(infile) as hdul:
+            hdulen = hdul[0]._data_offset + hdul[0]._data_size
+            hdu = fits.PrimaryHDU.fromstring(dat[:hdulen])
+            assert isinstance(hdu, fits.PrimaryHDU)
+            assert hdul[0].header == hdu.header
+            assert hdu.data is None
+
+        hdu.header['TEST'] = 'TEST'
+        hdu.writeto(outfile)
+        with fits.open(outfile) as hdul:
+            assert isinstance(hdu, fits.PrimaryHDU)
+            assert hdul[0].header[:-1] == hdu.header[:-1]
+            assert hdul[0].header['TEST'] == 'TEST'
+            assert hdu.data is None
+
+        with fits.open(infile)as hdul:
+            for ext_hdu in hdul[1:]:
+                offset += hdulen
+                hdulen = len(str(ext_hdu.header)) + ext_hdu._data_size
+                hdu = fits.ImageHDU.fromstring(dat[offset:offset + hdulen])
+                assert isinstance(hdu, fits.ImageHDU)
+                assert ext_hdu.header == hdu.header
+                assert (ext_hdu.data == hdu.data).all()
+
+    def test_nonstandard_hdu(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/157
+
+        Tests that "Nonstandard" HDUs with SIMPLE = F are read and written
+        without prepending a superfluous and unwanted standard primary HDU.
+        """
+
+        data = np.arange(100, dtype=np.uint8)
+        hdu = fits.PrimaryHDU(data=data)
+        hdu.header['SIMPLE'] = False
+        hdu.writeto(self.temp('test.fits'))
+
+        info = [(0, '', 1, 'NonstandardHDU', 5, (), '', '')]
+        with fits.open(self.temp('test.fits')) as hdul:
+            assert hdul.info(output=False) == info
+            # NonstandardHDUs just treat the data as an unspecified array of
+            # bytes.  The first 100 bytes should match the original data we
+            # passed in...the rest should be zeros padding out the rest of the
+            # FITS block
+            assert (hdul[0].data[:100] == data).all()
+            assert (hdul[0].data[100:] == 0).all()
+
+    def test_extname(self):
+        """Test getting/setting the EXTNAME of an HDU."""
+
+        h1 = fits.PrimaryHDU()
+        assert h1.name == 'PRIMARY'
+        # Normally a PRIMARY HDU should not have an EXTNAME, though it should
+        # have a default .name attribute
+        assert 'EXTNAME' not in h1.header
+
+        # The current version of the FITS standard does allow PRIMARY HDUs to
+        # have an EXTNAME, however.
+        h1.name = 'NOTREAL'
+        assert h1.name == 'NOTREAL'
+        assert h1.header.get('EXTNAME') == 'NOTREAL'
+
+        # Updating the EXTNAME in the header should update the .name
+        h1.header['EXTNAME'] = 'TOOREAL'
+        assert h1.name == 'TOOREAL'
+
+        # If we delete an EXTNAME keyword from a PRIMARY HDU it should go back
+        # to the default
+        del h1.header['EXTNAME']
+        assert h1.name == 'PRIMARY'
+
+        # For extension HDUs the situation is a bit simpler:
+        h2 = fits.ImageHDU()
+        assert h2.name == ''
+        assert 'EXTNAME' not in h2.header
+        h2.name = 'HELLO'
+        assert h2.name == 'HELLO'
+        assert h2.header.get('EXTNAME') == 'HELLO'
+        h2.header['EXTNAME'] = 'GOODBYE'
+        assert h2.name == 'GOODBYE'
+
+    def test_extver_extlevel(self):
+        """Test getting/setting the EXTVER and EXTLEVEL of and HDU."""
+
+        # EXTVER and EXTNAME work exactly the same; their semantics are, for
+        # now, to be inferred by the user.  Although they should never be less
+        # than 1, the standard does not explicitly forbid any value so long as
+        # it's an integer
+        h1 = fits.PrimaryHDU()
+        assert h1.ver == 1
+        assert h1.level == 1
+        assert 'EXTVER' not in h1.header
+        assert 'EXTLEVEL' not in h1.header
+
+        h1.ver = 2
+        assert h1.header.get('EXTVER') == 2
+        h1.header['EXTVER'] = 3
+        assert h1.ver == 3
+        del h1.header['EXTVER']
+        h1.ver == 1
+
+        h1.level = 2
+        assert h1.header.get('EXTLEVEL') == 2
+        h1.header['EXTLEVEL'] = 3
+        assert h1.level == 3
+        del h1.header['EXTLEVEL']
+        assert h1.level == 1
+
+        pytest.raises(TypeError, setattr, h1, 'ver', 'FOO')
+        pytest.raises(TypeError, setattr, h1, 'level', 'BAR')
+
+    def test_consecutive_writeto(self):
+        """
+        Regression test for an issue where calling writeto twice on the same
+        HDUList could write a corrupted file.
+
+        https://github.com/spacetelescope/PyFITS/issues/40 is actually a
+        particular instance of this problem, though isn't unique to sys.stdout.
+        """
+
+        with fits.open(self.data('test0.fits')) as hdul1:
+            # Add a bunch of header keywords so that the data will be forced to
+            # new offsets within the file:
+            for idx in range(40):
+                hdul1[1].header['TEST{}'.format(idx)] = 'test'
+
+            hdul1.writeto(self.temp('test1.fits'))
+            hdul1.writeto(self.temp('test2.fits'))
+
+            # Open a second handle to the original file and compare it to hdul1
+            # (We only compare part of the one header that was modified)
+            # Compare also with the second writeto output
+            with fits.open(self.data('test0.fits')) as hdul2:
+                with fits.open(self.temp('test2.fits')) as hdul3:
+                    for hdul in (hdul1, hdul3):
+                        for idx, hdus in enumerate(zip(hdul2, hdul)):
+                            hdu2, hdu = hdus
+                            if idx != 1:
+                                assert hdu.header == hdu2.header
+                            else:
+                                assert (hdu2.header ==
+                                        hdu.header[:len(hdu2.header)])
+                            assert np.all(hdu.data == hdu2.data)
+
+
+class TestConvenienceFunctions(FitsTestCase):
+    def test_writeto(self):
+        """
+        Simple test for writing a trivial header and some data to a file
+        with the `writeto()` convenience function.
+        """
+        filename = self.temp('array.fits')
+        data = np.zeros((100, 100))
+        header = fits.Header()
+        fits.writeto(filename, data, header=header, overwrite=True)
+        with fits.open(filename) as hdul:
+            assert len(hdul) == 1
+            assert (data == hdul[0].data).all()
+
+    def test_writeto_2(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/107
+
+        Test of `writeto()` with a trivial header containing a single keyword.
+        """
+        filename = self.temp('array.fits')
+        data = np.zeros((100, 100))
+        header = fits.Header()
+        header.set('CRPIX1', 1.)
+        fits.writeto(filename, data, header=header,
+                     overwrite=True, output_verify='silentfix')
+        with fits.open(filename) as hdul:
+            assert len(hdul) == 1
+            assert (data == hdul[0].data).all()
+            assert 'CRPIX1' in hdul[0].header
+            assert hdul[0].header['CRPIX1'] == 1.0
+
+
+class TestFileFunctions(FitsTestCase):
+    """
+    Tests various basic I/O operations, specifically in the
+    astropy.io.fits.file._File class.
+    """
+
+    def test_open_nonexistent(self):
+        """Test that trying to open a non-existent file results in an
+        OSError (and not some other arbitrary exception).
+        """
+
+        try:
+            fits.open(self.temp('foobar.fits'))
+        except OSError as e:
+            assert 'No such file or directory' in str(e)
+
+        # But opening in ostream or append mode should be okay, since they
+        # allow writing new files
+        for mode in ('ostream', 'append'):
+            with fits.open(self.temp('foobar.fits'), mode=mode) as h:
+                pass
+
+            assert os.path.exists(self.temp('foobar.fits'))
+            os.remove(self.temp('foobar.fits'))
+
+    def test_open_file_handle(self):
+        # Make sure we can open a FITS file from an open file handle
+        with open(self.data('test0.fits'), 'rb') as handle:
+            with fits.open(handle) as fitsfile:
+                pass
+
+        with open(self.temp('temp.fits'), 'wb') as handle:
+            with fits.open(handle, mode='ostream') as fitsfile:
+                pass
+
+        # Opening without explicitly specifying binary mode should fail
+        with pytest.raises(ValueError):
+            with open(self.data('test0.fits')) as handle:
+                with fits.open(handle) as fitsfile:
+                    pass
+
+        # All of these read modes should fail
+        for mode in ['r', 'rt']:
+            with pytest.raises(ValueError):
+                with open(self.data('test0.fits'), mode=mode) as handle:
+                    with fits.open(handle) as fitsfile:
+                        pass
+
+        # These update or write modes should fail as well
+        for mode in ['w', 'wt', 'w+', 'wt+', 'r+', 'rt+',
+                     'a', 'at', 'a+', 'at+']:
+            with pytest.raises(ValueError):
+                with open(self.temp('temp.fits'), mode=mode) as handle:
+                    with fits.open(handle) as fitsfile:
+                        pass
+
+    def test_fits_file_handle_mode_combo(self):
+        # This should work fine since no mode is given
+        with open(self.data('test0.fits'), 'rb') as handle:
+            with fits.open(handle) as fitsfile:
+                pass
+
+        # This should work fine since the modes are compatible
+        with open(self.data('test0.fits'), 'rb') as handle:
+            with fits.open(handle, mode='readonly') as fitsfile:
+                pass
+
+        # This should not work since the modes conflict
+        with pytest.raises(ValueError):
+            with open(self.data('test0.fits'), 'rb') as handle:
+                with fits.open(handle, mode='ostream') as fitsfile:
+                    pass
+
+    def test_open_from_url(self):
+        import urllib.request
+        file_url = "file:///" + self.data('test0.fits')
+        with urllib.request.urlopen(file_url) as urlobj:
+            with fits.open(urlobj) as fits_handle:
+                pass
+
+        # It will not be possible to write to a file that is from a URL object
+        for mode in ('ostream', 'append', 'update'):
+            with pytest.raises(ValueError):
+                with urllib.request.urlopen(file_url) as urlobj:
+                    with fits.open(urlobj, mode=mode) as fits_handle:
+                        pass
+
+    @pytest.mark.remote_data(source='astropy')
+    def test_open_from_remote_url(self):
+
+        import urllib.request
+
+        for dataurl in (conf.dataurl, conf.dataurl_mirror):
+
+            remote_url = '{}/{}'.format(dataurl, 'allsky/allsky_rosat.fits')
+
+            try:
+
+                with urllib.request.urlopen(remote_url) as urlobj:
+                    with fits.open(urlobj) as fits_handle:
+                        assert len(fits_handle) == 1
+
+                for mode in ('ostream', 'append', 'update'):
+                    with pytest.raises(ValueError):
+                        with urllib.request.urlopen(remote_url) as urlobj:
+                            with fits.open(urlobj, mode=mode) as fits_handle:
+                                assert len(fits_handle) == 1
+
+            except (urllib.error.HTTPError, urllib.error.URLError):
+                continue
+            else:
+                break
+        else:
+            raise Exception("Could not download file")
+
+    def test_open_gzipped(self):
+        gzip_file = self._make_gzip_file()
+        with ignore_warnings():
+            with fits.open(gzip_file) as fits_handle:
+                assert fits_handle._file.compression == 'gzip'
+                assert len(fits_handle) == 5
+            with fits.open(gzip.GzipFile(gzip_file)) as fits_handle:
+                assert fits_handle._file.compression == 'gzip'
+                assert len(fits_handle) == 5
+
+    def test_open_gzipped_from_handle(self):
+        with open(self._make_gzip_file(), 'rb') as handle:
+            with fits.open(handle) as fits_handle:
+                assert fits_handle._file.compression == 'gzip'
+
+    def test_detect_gzipped(self):
+        """Test detection of a gzip file when the extension is not .gz."""
+        with ignore_warnings():
+            with fits.open(self._make_gzip_file('test0.fz')) as fits_handle:
+                assert fits_handle._file.compression == 'gzip'
+                assert len(fits_handle) == 5
+
+    def test_writeto_append_mode_gzip(self):
+        """Regression test for
+        https://github.com/spacetelescope/PyFITS/issues/33
+
+        Check that a new GzipFile opened in append mode can be used to write
+        out a new FITS file.
+        """
+
+        # Note: when opening a GzipFile the 'b+' is superfluous, but this was
+        # still how the original test case looked
+        # Note: with statement not supported on GzipFile in older Python
+        # versions
+        fileobj = gzip.GzipFile(self.temp('test.fits.gz'), 'ab+')
+        h = fits.PrimaryHDU()
+        try:
+            h.writeto(fileobj)
+        finally:
+            fileobj.close()
+
+        with fits.open(self.temp('test.fits.gz')) as hdul:
+            assert hdul[0].header == h.header
+
+    def test_fits_update_mode_gzip(self):
+        """Test updating a GZipped FITS file"""
+
+        with fits.open(self._make_gzip_file('update.gz'), mode='update') as fits_handle:
+            hdu = fits.ImageHDU(data=[x for x in range(100)])
+            fits_handle.append(hdu)
+
+        with fits.open(self.temp('update.gz')) as new_handle:
+            assert len(new_handle) == 6
+            assert (new_handle[-1].data == [x for x in range(100)]).all()
+
+    def test_fits_append_mode_gzip(self):
+        """Make sure that attempting to open an existing GZipped FITS file in
+        'append' mode raises an error"""
+
+        with pytest.raises(OSError):
+            with fits.open(self._make_gzip_file('append.gz'), mode='append') as fits_handle:
+                pass
+
+    def test_open_bzipped(self):
+        bzip_file = self._make_bzip2_file()
+        with ignore_warnings():
+            with fits.open(bzip_file) as fits_handle:
+                assert fits_handle._file.compression == 'bzip2'
+                assert len(fits_handle) == 5
+
+            with fits.open(bz2.BZ2File(bzip_file)) as fits_handle:
+                assert fits_handle._file.compression == 'bzip2'
+                assert len(fits_handle) == 5
+
+    def test_open_bzipped_from_handle(self):
+        with open(self._make_bzip2_file(), 'rb') as handle:
+            with fits.open(handle) as fits_handle:
+                assert fits_handle._file.compression == 'bzip2'
+                assert len(fits_handle) == 5
+
+    def test_detect_bzipped(self):
+        """Test detection of a bzip2 file when the extension is not .bz2."""
+        with ignore_warnings():
+            with fits.open(self._make_bzip2_file('test0.xx')) as fits_handle:
+                assert fits_handle._file.compression == 'bzip2'
+                assert len(fits_handle) == 5
+
+    def test_writeto_bzip2_fileobj(self):
+        """Test writing to a bz2.BZ2File file like object"""
+        fileobj = bz2.BZ2File(self.temp('test.fits.bz2'), 'w')
+        h = fits.PrimaryHDU()
+        try:
+            h.writeto(fileobj)
+        finally:
+            fileobj.close()
+
+        with fits.open(self.temp('test.fits.bz2')) as hdul:
+            assert hdul[0].header == h.header
+
+    def test_writeto_bzip2_filename(self):
+        """Test writing to a bzip2 file by name"""
+        filename = self.temp('testname.fits.bz2')
+        h = fits.PrimaryHDU()
+        h.writeto(filename)
+
+        with fits.open(self.temp('testname.fits.bz2')) as hdul:
+            assert hdul[0].header == h.header
+
+    def test_open_zipped(self):
+        zip_file = self._make_zip_file()
+        with ignore_warnings():
+            with fits.open(zip_file) as fits_handle:
+                assert fits_handle._file.compression == 'zip'
+                assert len(fits_handle) == 5
+            with fits.open(zipfile.ZipFile(zip_file)) as fits_handle:
+                assert fits_handle._file.compression == 'zip'
+                assert len(fits_handle) == 5
+
+    def test_open_zipped_from_handle(self):
+        with open(self._make_zip_file(), 'rb') as handle:
+            with fits.open(handle) as fits_handle:
+                assert fits_handle._file.compression == 'zip'
+                assert len(fits_handle) == 5
+
+    def test_detect_zipped(self):
+        """Test detection of a zip file when the extension is not .zip."""
+
+        zf = self._make_zip_file(filename='test0.fz')
+        with ignore_warnings():
+            assert len(fits.open(zf)) == 5
+
+    def test_open_zipped_writeable(self):
+        """Opening zipped files in a writeable mode should fail."""
+
+        zf = self._make_zip_file()
+        pytest.raises(OSError, fits.open, zf, 'update')
+        pytest.raises(OSError, fits.open, zf, 'append')
+
+        zf = zipfile.ZipFile(zf, 'a')
+        pytest.raises(OSError, fits.open, zf, 'update')
+        pytest.raises(OSError, fits.open, zf, 'append')
+
+    def test_read_open_astropy_gzip_file(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/2774
+
+        This tests reading from a ``GzipFile`` object from Astropy's
+        compatibility copy of the ``gzip`` module.
+        """
+        gf = gzip.GzipFile(self._make_gzip_file())
+        try:
+            assert len(fits.open(gf)) == 5
+        finally:
+            gf.close()
+
+    @raises(OSError)
+    def test_open_multiple_member_zipfile(self):
+        """
+        Opening zip files containing more than one member files should fail
+        as there's no obvious way to specify which file is the FITS file to
+        read.
+        """
+
+        zfile = zipfile.ZipFile(self.temp('test0.zip'), 'w')
+        zfile.write(self.data('test0.fits'))
+        zfile.writestr('foo', 'bar')
+        zfile.close()
+
+        fits.open(zfile.filename)
+
+    def test_read_open_file(self):
+        """Read from an existing file object."""
+
+        with open(self.data('test0.fits'), 'rb') as f:
+            assert len(fits.open(f)) == 5
+
+    def test_read_closed_file(self):
+        """Read from an existing file object that's been closed."""
+
+        f = open(self.data('test0.fits'), 'rb')
+        f.close()
+        with fits.open(f) as f2:
+            assert len(f2) == 5
+
+    def test_read_open_gzip_file(self):
+        """Read from an open gzip file object."""
+
+        gf = gzip.GzipFile(self._make_gzip_file())
+        try:
+            assert len(fits.open(gf)) == 5
+        finally:
+            gf.close()
+
+    def test_open_gzip_file_for_writing(self):
+        """Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/195."""
+
+        gf = self._make_gzip_file()
+        with fits.open(gf, mode='update') as h:
+            h[0].header['EXPFLAG'] = 'ABNORMAL'
+            h[1].data[0, 0] = 1
+        with fits.open(gf) as h:
+            # Just to make sur ethe update worked; if updates work
+            # normal writes should work too...
+            assert h[0].header['EXPFLAG'] == 'ABNORMAL'
+            assert h[1].data[0, 0] == 1
+
+    def test_write_read_gzip_file(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/2794
+
+        Ensure files written through gzip are readable.
+        """
+
+        data = np.arange(100)
+        hdu = fits.PrimaryHDU(data=data)
+        hdu.writeto(self.temp('test.fits.gz'))
+
+        with open(self.temp('test.fits.gz'), 'rb') as f:
+            assert f.read(3) == GZIP_MAGIC
+
+        with fits.open(self.temp('test.fits.gz')) as hdul:
+            assert np.all(hdul[0].data == data)
+
+    def test_read_file_like_object(self):
+        """Test reading a FITS file from a file-like object."""
+
+        filelike = io.BytesIO()
+        with open(self.data('test0.fits'), 'rb') as f:
+            filelike.write(f.read())
+        filelike.seek(0)
+        with ignore_warnings():
+            assert len(fits.open(filelike)) == 5
+
+    def test_updated_file_permissions(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/79
+
+        Tests that when a FITS file is modified in update mode, the file
+        permissions are preserved.
+        """
+
+        filename = self.temp('test.fits')
+        hdul = [fits.PrimaryHDU(), fits.ImageHDU()]
+        hdul = fits.HDUList(hdul)
+        hdul.writeto(filename)
+
+        old_mode = os.stat(filename).st_mode
+
+        hdul = fits.open(filename, mode='update')
+        hdul.insert(1, fits.ImageHDU())
+        hdul.flush()
+        hdul.close()
+
+        assert old_mode == os.stat(filename).st_mode
+
+    def test_fileobj_mode_guessing(self):
+        """Tests whether a file opened without a specified io.fits mode
+        ('readonly', etc.) is opened in a mode appropriate for the given file
+        object.
+        """
+
+        self.copy_file('test0.fits')
+
+        # Opening in text mode should outright fail
+        for mode in ('r', 'w', 'a'):
+            with open(self.temp('test0.fits'), mode) as f:
+                pytest.raises(ValueError, fits.HDUList.fromfile, f)
+
+        # Need to re-copy the file since opening it in 'w' mode blew it away
+        self.copy_file('test0.fits')
+
+        with open(self.temp('test0.fits'), 'rb') as f:
+            with fits.HDUList.fromfile(f) as h:
+                assert h.fileinfo(0)['filemode'] == 'readonly'
+
+        for mode in ('wb', 'ab'):
+            with open(self.temp('test0.fits'), mode) as f:
+                with fits.HDUList.fromfile(f) as h:
+                    # Basically opening empty files for output streaming
+                    assert len(h) == 0
+
+        # Need to re-copy the file since opening it in 'w' mode blew it away
+        self.copy_file('test0.fits')
+
+        with open(self.temp('test0.fits'), 'wb+') as f:
+            with fits.HDUList.fromfile(f) as h:
+                # wb+ still causes an existing file to be overwritten so there
+                # are no HDUs
+                assert len(h) == 0
+
+        # Need to re-copy the file since opening it in 'w' mode blew it away
+        self.copy_file('test0.fits')
+
+        with open(self.temp('test0.fits'), 'rb+') as f:
+            with fits.HDUList.fromfile(f) as h:
+                assert h.fileinfo(0)['filemode'] == 'update'
+
+        with open(self.temp('test0.fits'), 'ab+') as f:
+            with fits.HDUList.fromfile(f) as h:
+                assert h.fileinfo(0)['filemode'] == 'append'
+
+    def test_mmap_unwriteable(self):
+        """Regression test for https://github.com/astropy/astropy/issues/968
+
+        Temporarily patches mmap.mmap to exhibit platform-specific bad
+        behavior.
+        """
+
+        class MockMmap(mmap.mmap):
+            def flush(self):
+                raise OSError('flush is broken on this platform')
+
+        old_mmap = mmap.mmap
+        mmap.mmap = MockMmap
+
+        # Force the mmap test to be rerun
+        _File.__dict__['_mmap_available']._cache.clear()
+
+        try:
+            self.copy_file('test0.fits')
+            with catch_warnings() as w:
+                with fits.open(self.temp('test0.fits'), mode='update',
+                               memmap=True) as h:
+                    h[1].data[0, 0] = 999
+
+                assert len(w) == 1
+                assert 'mmap.flush is unavailable' in str(w[0].message)
+
+            # Double check that writing without mmap still worked
+            with fits.open(self.temp('test0.fits')) as h:
+                assert h[1].data[0, 0] == 999
+        finally:
+            mmap.mmap = old_mmap
+            _File.__dict__['_mmap_available']._cache.clear()
+
+    @pytest.mark.openfiles_ignore
+    def test_mmap_allocate_error(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/1380
+
+        Temporarily patches mmap.mmap to raise an OSError if mode is ACCESS_COPY.
+        """
+
+        mmap_original = mmap.mmap
+
+        # We patch mmap here to raise an error if access=mmap.ACCESS_COPY, which
+        # emulates an issue that an OSError is raised if the available address
+        # space is less than the size of the file even if memory mapping is used.
+
+        def mmap_patched(*args, **kwargs):
+            if kwargs.get('access') == mmap.ACCESS_COPY:
+                exc = OSError()
+                exc.errno = errno.ENOMEM
+                raise exc
+            else:
+                return mmap_original(*args, **kwargs)
+
+        with fits.open(self.data('test0.fits'), memmap=True) as hdulist:
+            with patch.object(mmap, 'mmap', side_effect=mmap_patched) as p:
+                with pytest.warns(AstropyUserWarning, match="Could not memory "
+                                  "map array with mode='readonly'"):
+                    data = hdulist[1].data
+                p.reset_mock()
+            assert not data.flags.writeable
+
+    def test_mmap_closing(self):
+        """
+        Tests that the mmap reference is closed/removed when there aren't any
+        HDU data references left.
+        """
+
+        if not _File._mmap_available:
+            pytest.xfail('not expected to work on platforms without mmap '
+                         'support')
+
+        with fits.open(self.data('test0.fits'), memmap=True) as hdul:
+            assert hdul._file._mmap is None
+
+            hdul[1].data
+            assert hdul._file._mmap is not None
+
+            del hdul[1].data
+            # Should be no more references to data in the file so close the
+            # mmap
+            assert hdul._file._mmap is None
+
+            hdul[1].data
+            hdul[2].data
+            del hdul[1].data
+            # hdul[2].data is still references so keep the mmap open
+            assert hdul._file._mmap is not None
+            del hdul[2].data
+            assert hdul._file._mmap is None
+
+        assert hdul._file._mmap is None
+
+        with fits.open(self.data('test0.fits'), memmap=True) as hdul:
+            hdul[1].data
+
+        # When the only reference to the data is on the hdu object, and the
+        # hdulist it belongs to has been closed, the mmap should be closed as
+        # well
+        assert hdul._file._mmap is None
+
+        with fits.open(self.data('test0.fits'), memmap=True) as hdul:
+            data = hdul[1].data
+            # also make a copy
+            data_copy = data.copy()
+
+        # The HDUList is closed; in fact, get rid of it completely
+        del hdul
+
+        # The data array should still work though...
+        assert np.all(data == data_copy)
+
+    def test_uncloseable_file(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/2356
+
+        Demonstrates that FITS files can still be read from "file-like" objects
+        that don't have an obvious "open" or "closed" state.
+        """
+
+        class MyFileLike:
+            def __init__(self, foobar):
+                self._foobar = foobar
+
+            def read(self, n):
+                return self._foobar.read(n)
+
+            def seek(self, offset, whence=os.SEEK_SET):
+                self._foobar.seek(offset, whence)
+
+            def tell(self):
+                return self._foobar.tell()
+
+        with open(self.data('test0.fits'), 'rb') as f:
+            fileobj = MyFileLike(f)
+
+            with fits.open(fileobj) as hdul1:
+                with fits.open(self.data('test0.fits')) as hdul2:
+                    assert hdul1.info(output=False) == hdul2.info(output=False)
+                    for hdu1, hdu2 in zip(hdul1, hdul2):
+                        assert hdu1.header == hdu2.header
+                        if hdu1.data is not None and hdu2.data is not None:
+                            assert np.all(hdu1.data == hdu2.data)
+
+    def test_write_bytesio_discontiguous(self):
+        """
+        Regression test related to
+        https://github.com/astropy/astropy/issues/2794#issuecomment-55441539
+
+        Demonstrates that writing an HDU containing a discontiguous Numpy array
+        should work properly.
+        """
+
+        data = np.arange(100)[::3]
+        hdu = fits.PrimaryHDU(data=data)
+        fileobj = io.BytesIO()
+        hdu.writeto(fileobj)
+
+        fileobj.seek(0)
+
+        with fits.open(fileobj) as h:
+            assert np.all(h[0].data == data)
+
+    def test_write_bytesio(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/2463
+
+        Test againt `io.BytesIO`.  `io.StringIO` is not supported.
+        """
+
+        self._test_write_string_bytes_io(io.BytesIO())
+
+    @pytest.mark.skipif(str('sys.platform.startswith("win32")'))
+    def test_filename_with_colon(self):
+        """
+        Test reading and writing a file with a colon in the filename.
+
+        Regression test for https://github.com/astropy/astropy/issues/3122
+        """
+
+        # Skip on Windows since colons in filenames makes NTFS sad.
+
+        filename = 'APEXHET.2014-04-01T15:18:01.000.fits'
+        hdu = fits.PrimaryHDU(data=np.arange(10))
+        hdu.writeto(self.temp(filename))
+
+        with fits.open(self.temp(filename)) as hdul:
+            assert np.all(hdul[0].data == hdu.data)
+
+    def test_writeto_full_disk(self, monkeypatch):
+        """
+        Test that it gives a readable error when trying to write an hdulist
+        to a full disk.
+        """
+
+        def _writeto(self, array):
+            raise OSError("Fake error raised when writing file.")
+
+        def get_free_space_in_dir(path):
+            return 0
+
+        with pytest.raises(OSError) as exc:
+            monkeypatch.setattr(fits.hdu.base._BaseHDU, "_writeto", _writeto)
+            monkeypatch.setattr(data, "get_free_space_in_dir", get_free_space_in_dir)
+
+            n = np.arange(0, 1000, dtype='int64')
+            hdu = fits.PrimaryHDU(n)
+            hdulist = fits.HDUList(hdu)
+            filename = self.temp('test.fits')
+
+            with open(filename, mode='wb') as fileobj:
+                hdulist.writeto(fileobj)
+
+        assert ("Not enough space on disk: requested 8000, available 0. "
+                "Fake error raised when writing file.") == exc.value.args[0]
+
+    def test_flush_full_disk(self, monkeypatch):
+        """
+        Test that it gives a readable error when trying to update an hdulist
+        to a full disk.
+        """
+        filename = self.temp('test.fits')
+        hdul = [fits.PrimaryHDU(), fits.ImageHDU()]
+        hdul = fits.HDUList(hdul)
+        hdul[0].data = np.arange(0, 1000, dtype='int64')
+        hdul.writeto(filename)
+
+        def _writedata(self, fileobj):
+            raise OSError("Fake error raised when writing file.")
+
+        def get_free_space_in_dir(path):
+            return 0
+
+        monkeypatch.setattr(fits.hdu.base._BaseHDU, "_writedata", _writedata)
+        monkeypatch.setattr(data, "get_free_space_in_dir",
+                            get_free_space_in_dir)
+
+        with pytest.raises(OSError) as exc:
+            with fits.open(filename, mode='update') as hdul:
+                hdul[0].data = np.arange(0, 1000, dtype='int64')
+                hdul.insert(1, fits.ImageHDU())
+                hdul.flush()
+
+        assert ("Not enough space on disk: requested 8000, available 0. "
+                "Fake error raised when writing file.") == exc.value.args[0]
+
+    def _test_write_string_bytes_io(self, fileobj):
+        """
+        Implemented for both test_write_stringio and test_write_bytesio.
+        """
+
+        with fits.open(self.data('test0.fits')) as hdul:
+            hdul.writeto(fileobj)
+            hdul2 = fits.HDUList.fromstring(fileobj.getvalue())
+            assert FITSDiff(hdul, hdul2).identical
+
+    def _make_gzip_file(self, filename='test0.fits.gz'):
+        gzfile = self.temp(filename)
+        with open(self.data('test0.fits'), 'rb') as f:
+            gz = gzip.open(gzfile, 'wb')
+            gz.write(f.read())
+            gz.close()
+
+        return gzfile
+
+    def _make_zip_file(self, mode='copyonwrite', filename='test0.fits.zip'):
+        zfile = zipfile.ZipFile(self.temp(filename), 'w')
+        zfile.write(self.data('test0.fits'))
+        zfile.close()
+
+        return zfile.filename
+
+    def _make_bzip2_file(self, filename='test0.fits.bz2'):
+        bzfile = self.temp(filename)
+        with open(self.data('test0.fits'), 'rb') as f:
+            bz = bz2.BZ2File(bzfile, 'w')
+            bz.write(f.read())
+            bz.close()
+
+        return bzfile
+
+
+class TestStreamingFunctions(FitsTestCase):
+    """Test functionality of the StreamingHDU class."""
+
+    def test_streaming_hdu(self):
+        shdu = self._make_streaming_hdu(self.temp('new.fits'))
+        assert isinstance(shdu.size, int)
+        assert shdu.size == 100
+        shdu.close()
+
+    @raises(ValueError)
+    def test_streaming_hdu_file_wrong_mode(self):
+        """
+        Test that streaming an HDU to a file opened in the wrong mode fails as
+        expected.
+        """
+
+        with open(self.temp('new.fits'), 'wb') as f:
+            header = fits.Header()
+            fits.StreamingHDU(f, header)
+
+    def test_streaming_hdu_write_file(self):
+        """Test streaming an HDU to an open file object."""
+
+        arr = np.zeros((5, 5), dtype=np.int32)
+        with open(self.temp('new.fits'), 'ab+') as f:
+            shdu = self._make_streaming_hdu(f)
+            shdu.write(arr)
+            assert shdu.writecomplete
+            assert shdu.size == 100
+        with fits.open(self.temp('new.fits')) as hdul:
+            assert len(hdul) == 1
+            assert (hdul[0].data == arr).all()
+
+    def test_streaming_hdu_write_file_like(self):
+        """Test streaming an HDU to an open file-like object."""
+
+        arr = np.zeros((5, 5), dtype=np.int32)
+        # The file-like object underlying a StreamingHDU must be in binary mode
+        sf = io.BytesIO()
+        shdu = self._make_streaming_hdu(sf)
+        shdu.write(arr)
+        assert shdu.writecomplete
+        assert shdu.size == 100
+
+        sf.seek(0)
+        hdul = fits.open(sf)
+        assert len(hdul) == 1
+        assert (hdul[0].data == arr).all()
+
+    def test_streaming_hdu_append_extension(self):
+        arr = np.zeros((5, 5), dtype=np.int32)
+        with open(self.temp('new.fits'), 'ab+') as f:
+            shdu = self._make_streaming_hdu(f)
+            shdu.write(arr)
+        # Doing this again should update the file with an extension
+        with open(self.temp('new.fits'), 'ab+') as f:
+            shdu = self._make_streaming_hdu(f)
+            shdu.write(arr)
+
+    def test_fix_invalid_extname(self, capsys):
+        phdu = fits.PrimaryHDU()
+        ihdu = fits.ImageHDU()
+        ihdu.header['EXTNAME'] = 12345678
+        hdul = fits.HDUList([phdu, ihdu])
+        filename = self.temp('temp.fits')
+
+        pytest.raises(fits.VerifyError, hdul.writeto, filename,
+                      output_verify='exception')
+        with pytest.warns(fits.verify.VerifyWarning,
+                          match='Verification reported errors'):
+            hdul.writeto(filename, output_verify='fix')
+        with fits.open(filename):
+            assert hdul[1].name == '12345678'
+            assert hdul[1].header['EXTNAME'] == '12345678'
+
+        hdul.close()
+
+    def _make_streaming_hdu(self, fileobj):
+        hd = fits.Header()
+        hd['SIMPLE'] = (True, 'conforms to FITS standard')
+        hd['BITPIX'] = (32, 'array data type')
+        hd['NAXIS'] = (2, 'number of array dimensions')
+        hd['NAXIS1'] = 5
+        hd['NAXIS2'] = 5
+        hd['EXTEND'] = True
+        return fits.StreamingHDU(fileobj, hd)
+
+    def test_blank_ignore(self):
+
+        with fits.open(self.data('blank.fits'), ignore_blank=True) as f:
+            assert f[0].data.flat[0] == 2
+
+    def test_error_if_memmap_impossible(self):
+        pth = self.data('blank.fits')
+        with fits.open(pth, memmap=True) as hdul:
+            with pytest.raises(ValueError):
+                hdul[0].data
+
+        # However, it should not fail if do_not_scale_image_data was used:
+        # See https://github.com/astropy/astropy/issues/3766
+        with fits.open(pth, memmap=True, do_not_scale_image_data=True) as hdul:
+            hdul[0].data  # Just make sure it doesn't crash

testbed/astropy__astropy/astropy/io/fits/tests/test_division.py

@@ -0,0 +1,42 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import numpy as np
+
+from astropy.io import fits
+from . import FitsTestCase
+from astropy.tests.helper import catch_warnings
+
+
+class TestDivisionFunctions(FitsTestCase):
+    """Test code units that rely on correct integer division."""
+
+    def test_rec_from_string(self):
+        with fits.open(self.data('tb.fits')) as t1:
+            s = t1[1].data.tostring()
+        np.rec.array(
+            s,
+            dtype=np.dtype([('c1', '>i4'), ('c2', '|S3'),
+                            ('c3', '>f4'), ('c4', '|i1')]),
+            shape=len(s) // 12)
+
+    def test_card_with_continue(self):
+        h = fits.PrimaryHDU()
+        with catch_warnings() as w:
+            h.header['abc'] = 'abcdefg' * 20
+        assert len(w) == 0
+
+    def test_valid_hdu_size(self):
+        with fits.open(self.data('tb.fits')) as t1:
+            assert type(t1[1].size) is type(1)  # noqa
+
+    def test_hdu_get_size(self):
+        with catch_warnings() as w:
+            t1 = fits.open(self.data('tb.fits'))
+        assert len(w) == 0
+
+    def test_section(self, capsys):
+        # section testing
+        fs = fits.open(self.data('arange.fits'))
+        with catch_warnings() as w:
+            assert np.all(fs[0].section[3, 2, 5] == np.array([357]))
+            assert len(w) == 0

testbed/astropy__astropy/astropy/io/fits/tests/test_fitscheck.py

@@ -0,0 +1,77 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+import pytest
+from . import FitsTestCase
+from astropy.io.fits.scripts import fitscheck
+from astropy.io import fits
+
+
+class TestFitscheck(FitsTestCase):
+    def test_noargs(self):
+        with pytest.raises(SystemExit) as e:
+            fitscheck.main(['-h'])
+        assert e.value.code == 0
+
+    def test_missing_file(self, capsys):
+        assert fitscheck.main(['missing.fits']) == 1
+        stdout, stderr = capsys.readouterr()
+        assert 'No such file or directory' in stderr
+
+    def test_valid_file(self, capsys):
+        testfile = self.data('checksum.fits')
+
+        assert fitscheck.main([testfile]) == 0
+        assert fitscheck.main([testfile, '--compliance']) == 0
+
+        assert fitscheck.main([testfile, '-v']) == 0
+        stdout, stderr = capsys.readouterr()
+        assert 'OK' in stderr
+
+    def test_remove_checksums(self, capsys):
+        self.copy_file('checksum.fits')
+        testfile = self.temp('checksum.fits')
+        assert fitscheck.main([testfile, '--checksum', 'remove']) == 1
+        assert fitscheck.main([testfile]) == 1
+        stdout, stderr = capsys.readouterr()
+        assert 'MISSING' in stderr
+
+    def test_no_checksums(self, capsys):
+        testfile = self.data('arange.fits')
+
+        assert fitscheck.main([testfile]) == 1
+        stdout, stderr = capsys.readouterr()
+        assert 'Checksum not found' in stderr
+
+        assert fitscheck.main([testfile, '--ignore-missing']) == 0
+        stdout, stderr = capsys.readouterr()
+        assert stderr == ''
+
+    def test_overwrite_invalid(self, capsys):
+        """
+        Tests that invalid checksum or datasum are overwriten when the file is
+        saved.
+        """
+        reffile = self.temp('ref.fits')
+        with fits.open(self.data('tb.fits')) as hdul:
+            hdul.writeto(reffile, checksum=True)
+
+        # replace checksums with wrong ones
+        testfile = self.temp('test.fits')
+        with fits.open(self.data('tb.fits')) as hdul:
+            hdul[0].header['DATASUM'] = '1       '
+            hdul[0].header['CHECKSUM'] = '8UgqATfo7TfoATfo'
+            hdul[1].header['DATASUM'] = '2349680925'
+            hdul[1].header['CHECKSUM'] = '11daD8bX98baA8bU'
+            hdul.writeto(testfile)
+
+        assert fitscheck.main([testfile]) == 1
+        stdout, stderr = capsys.readouterr()
+        assert 'BAD' in stderr
+        assert 'Checksum verification failed' in stderr
+
+        assert fitscheck.main([testfile, '--write', '--force']) == 1
+        stdout, stderr = capsys.readouterr()
+        assert 'BAD' in stderr
+
+        # check that the file was fixed
+        assert fitscheck.main([testfile]) == 0

testbed/astropy__astropy/astropy/io/fits/tests/test_fitsdiff.py

@@ -0,0 +1,313 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+import numpy as np
+import pytest
+import os
+
+from . import FitsTestCase
+from astropy.io.fits.convenience import writeto
+from astropy.io.fits.hdu import PrimaryHDU, hdulist
+from astropy.io.fits import Header, ImageHDU, HDUList
+from astropy.io.fits.scripts import fitsdiff
+from astropy.tests.helper import catch_warnings
+from astropy.utils.exceptions import AstropyDeprecationWarning
+from astropy.version import version
+
+
+class TestFITSDiff_script(FitsTestCase):
+
+    def test_noargs(self):
+        with pytest.raises(SystemExit) as e:
+            fitsdiff.main()
+        assert e.value.code == 2
+
+    def test_oneargargs(self):
+        with pytest.raises(SystemExit) as e:
+            fitsdiff.main(["file1"])
+        assert e.value.code == 2
+
+    def test_nodiff(self):
+        a = np.arange(100).reshape(10, 10)
+        hdu_a = PrimaryHDU(data=a)
+        b = a.copy()
+        hdu_b = PrimaryHDU(data=b)
+        tmp_a = self.temp('testa.fits')
+        tmp_b = self.temp('testb.fits')
+        hdu_a.writeto(tmp_a)
+        hdu_b.writeto(tmp_b)
+        numdiff = fitsdiff.main([tmp_a, tmp_b])
+        assert numdiff == 0
+
+    def test_onediff(self):
+        a = np.arange(100).reshape(10, 10)
+        hdu_a = PrimaryHDU(data=a)
+        b = a.copy()
+        b[1, 0] = 12
+        hdu_b = PrimaryHDU(data=b)
+        tmp_a = self.temp('testa.fits')
+        tmp_b = self.temp('testb.fits')
+        hdu_a.writeto(tmp_a)
+        hdu_b.writeto(tmp_b)
+        numdiff = fitsdiff.main([tmp_a, tmp_b])
+        assert numdiff == 1
+
+    def test_manydiff(self, capsys):
+        a = np.arange(100).reshape(10, 10)
+        hdu_a = PrimaryHDU(data=a)
+        b = a + 1
+        hdu_b = PrimaryHDU(data=b)
+        tmp_a = self.temp('testa.fits')
+        tmp_b = self.temp('testb.fits')
+        hdu_a.writeto(tmp_a)
+        hdu_b.writeto(tmp_b)
+
+        numdiff = fitsdiff.main([tmp_a, tmp_b])
+        out, err = capsys.readouterr()
+        assert numdiff == 1
+        assert out.splitlines()[-4:] == [
+            '        a> 9',
+            '        b> 10',
+            '     ...',
+            '     100 different pixels found (100.00% different).']
+
+        numdiff = fitsdiff.main(['-n', '1', tmp_a, tmp_b])
+        out, err = capsys.readouterr()
+        assert numdiff == 1
+        assert out.splitlines()[-4:] == [
+            '        a> 0',
+            '        b> 1',
+            '     ...',
+            '     100 different pixels found (100.00% different).']
+
+    def test_outputfile(self):
+        a = np.arange(100).reshape(10, 10)
+        hdu_a = PrimaryHDU(data=a)
+        b = a.copy()
+        b[1, 0] = 12
+        hdu_b = PrimaryHDU(data=b)
+        tmp_a = self.temp('testa.fits')
+        tmp_b = self.temp('testb.fits')
+        hdu_a.writeto(tmp_a)
+        hdu_b.writeto(tmp_b)
+
+        numdiff = fitsdiff.main(['-o', self.temp('diff.txt'), tmp_a, tmp_b])
+        assert numdiff == 1
+        with open(self.temp('diff.txt')) as f:
+            out = f.read()
+        assert out.splitlines()[-4:] == [
+            '     Data differs at [1, 2]:',
+            '        a> 10',
+            '        b> 12',
+            '     1 different pixels found (1.00% different).']
+
+    def test_atol(self):
+        a = np.arange(100, dtype=float).reshape(10, 10)
+        hdu_a = PrimaryHDU(data=a)
+        b = a.copy()
+        b[1, 0] = 11
+        hdu_b = PrimaryHDU(data=b)
+        tmp_a = self.temp('testa.fits')
+        tmp_b = self.temp('testb.fits')
+        hdu_a.writeto(tmp_a)
+        hdu_b.writeto(tmp_b)
+
+        numdiff = fitsdiff.main(["-a", "1", tmp_a, tmp_b])
+        assert numdiff == 0
+
+        numdiff = fitsdiff.main(["--exact", "-a", "1", tmp_a, tmp_b])
+        assert numdiff == 1
+
+    def test_rtol(self):
+        a = np.arange(100, dtype=float).reshape(10, 10)
+        hdu_a = PrimaryHDU(data=a)
+        b = a.copy()
+        b[1, 0] = 11
+        hdu_b = PrimaryHDU(data=b)
+        tmp_a = self.temp('testa.fits')
+        tmp_b = self.temp('testb.fits')
+        hdu_a.writeto(tmp_a)
+        hdu_b.writeto(tmp_b)
+        numdiff = fitsdiff.main(["-r", "1e-1", tmp_a, tmp_b])
+        assert numdiff == 0
+
+    def test_rtol_diff(self, capsys):
+        a = np.arange(100, dtype=float).reshape(10, 10)
+        hdu_a = PrimaryHDU(data=a)
+        b = a.copy()
+        b[1, 0] = 11
+        hdu_b = PrimaryHDU(data=b)
+        tmp_a = self.temp('testa.fits')
+        tmp_b = self.temp('testb.fits')
+        hdu_a.writeto(tmp_a)
+        hdu_b.writeto(tmp_b)
+        numdiff = fitsdiff.main(["-r", "1e-2", tmp_a, tmp_b])
+        assert numdiff == 1
+        out, err = capsys.readouterr()
+        assert out == """
+ fitsdiff: {}
+ a: {}
+ b: {}
+ Maximum number of different data values to be reported: 10
+ Relative tolerance: 0.01, Absolute tolerance: 0.0
+
+Primary HDU:\n\n   Data contains differences:
+     Data differs at [1, 2]:
+        a> 10.0
+         ?  ^
+        b> 11.0
+         ?  ^
+     1 different pixels found (1.00% different).\n""".format(version, tmp_a, tmp_b)
+        assert err == ""
+
+    def test_fitsdiff_script_both_d_and_r(self, capsys):
+        a = np.arange(100).reshape(10, 10)
+        hdu_a = PrimaryHDU(data=a)
+        b = a.copy()
+        hdu_b = PrimaryHDU(data=b)
+        tmp_a = self.temp('testa.fits')
+        tmp_b = self.temp('testb.fits')
+        hdu_a.writeto(tmp_a)
+        hdu_b.writeto(tmp_b)
+        with catch_warnings(AstropyDeprecationWarning) as warning_lines:
+            fitsdiff.main(["-r", "1e-4", "-d", "1e-2", tmp_a, tmp_b])
+            # `rtol` is always ignored when `tolerance` is provided
+            assert warning_lines[0].category == AstropyDeprecationWarning
+            assert (str(warning_lines[0].message) ==
+                    '"-d" ("--difference-tolerance") was deprecated in version 2.0 '
+                    'and will be removed in a future version. '
+                    'Use "-r" ("--relative-tolerance") instead.')
+        out, err = capsys.readouterr()
+        assert out == """
+ fitsdiff: {}
+ a: {}
+ b: {}
+ Maximum number of different data values to be reported: 10
+ Relative tolerance: 0.01, Absolute tolerance: 0.0
+
+No differences found.\n""".format(version, tmp_a, tmp_b)
+
+    def test_wildcard(self):
+        tmp1 = self.temp("tmp_file1")
+        with pytest.raises(SystemExit) as e:
+            fitsdiff.main([tmp1+"*", "ACME"])
+        assert e.value.code == 2
+
+    def test_not_quiet(self, capsys):
+        a = np.arange(100).reshape(10, 10)
+        hdu_a = PrimaryHDU(data=a)
+        b = a.copy()
+        hdu_b = PrimaryHDU(data=b)
+        tmp_a = self.temp('testa.fits')
+        tmp_b = self.temp('testb.fits')
+        hdu_a.writeto(tmp_a)
+        hdu_b.writeto(tmp_b)
+        numdiff = fitsdiff.main([tmp_a, tmp_b])
+        assert numdiff == 0
+        out, err = capsys.readouterr()
+        assert out == """
+ fitsdiff: {}
+ a: {}
+ b: {}
+ Maximum number of different data values to be reported: 10
+ Relative tolerance: 0.0, Absolute tolerance: 0.0
+
+No differences found.\n""".format(version, tmp_a, tmp_b)
+        assert err == ""
+
+    def test_quiet(self, capsys):
+        a = np.arange(100).reshape(10, 10)
+        hdu_a = PrimaryHDU(data=a)
+        b = a.copy()
+        hdu_b = PrimaryHDU(data=b)
+        tmp_a = self.temp('testa.fits')
+        tmp_b = self.temp('testb.fits')
+        hdu_a.writeto(tmp_a)
+        hdu_b.writeto(tmp_b)
+        numdiff = fitsdiff.main(["-q", tmp_a, tmp_b])
+        assert numdiff == 0
+        out, err = capsys.readouterr()
+        assert out == ""
+        assert err == ""
+
+    def test_path(self, capsys):
+        os.mkdir(self.temp('sub/'))
+        tmp_b = self.temp('sub/ascii.fits')
+
+        tmp_g = self.temp('sub/group.fits')
+        tmp_h = self.data('group.fits')
+        with hdulist.fitsopen(tmp_h) as hdu_b:
+            hdu_b.writeto(tmp_g)
+
+        writeto(tmp_b, np.arange(100).reshape(10, 10))
+
+        # one modified file and a directory
+        assert fitsdiff.main(["-q", self.data_dir, tmp_b]) == 1
+        assert fitsdiff.main(["-q", tmp_b, self.data_dir]) == 1
+
+        # two directories
+        tmp_d = self.temp('sub/')
+        assert fitsdiff.main(["-q", self.data_dir, tmp_d]) == 1
+        assert fitsdiff.main(["-q", tmp_d, self.data_dir]) == 1
+        with pytest.warns(UserWarning, match="Field 'ORBPARM' has a repeat "
+                          "count of 0 in its format code"):
+            assert fitsdiff.main(["-q", self.data_dir, self.data_dir]) == 0
+
+        # no match
+        tmp_c = self.data('arange.fits')
+        fitsdiff.main([tmp_c, tmp_d])
+        out, err = capsys.readouterr()
+        assert "'arange.fits' has no match in" in err
+
+        # globbing
+        with pytest.warns(UserWarning, match="Field 'ORBPARM' has a repeat "
+                          "count of 0 in its format code"):
+            assert fitsdiff.main(["-q", self.data_dir+'/*.fits',
+                                  self.data_dir]) == 0
+        assert fitsdiff.main(["-q", self.data_dir+'/g*.fits', tmp_d]) == 0
+
+        # one file and a directory
+        tmp_f = self.data('tb.fits')
+        assert fitsdiff.main(["-q", tmp_f, self.data_dir]) == 0
+        assert fitsdiff.main(["-q", self.data_dir, tmp_f]) == 0
+
+    def test_ignore_hdus(self):
+        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])
+        assert numdiff == 1
+
+        numdiff = fitsdiff.main([tmp_a, tmp_b, "-u", "SCI"])
+        assert numdiff == 0
+
+    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

testbed/astropy__astropy/astropy/io/fits/tests/test_fitsheader.py

@@ -0,0 +1,136 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+import pytest
+
+from . import FitsTestCase
+from astropy.io.fits.scripts import fitsheader
+
+
+class TestFITSheader_script(FitsTestCase):
+
+    def test_noargs(self):
+        with pytest.raises(SystemExit) as e:
+            fitsheader.main(['-h'])
+        assert e.value.code == 0
+
+    def test_file_exists(self, capsys):
+        fitsheader.main([self.data('arange.fits')])
+        out, err = capsys.readouterr()
+        assert out.splitlines()[1].startswith(
+            'SIMPLE  =                    T / conforms to FITS standard')
+        assert err == ''
+
+    def test_by_keyword(self, capsys):
+        fitsheader.main(['-k', 'NAXIS', self.data('arange.fits')])
+        out, err = capsys.readouterr()
+        assert out.splitlines()[1].startswith(
+            'NAXIS   =                    3 / number of array dimensions')
+
+        fitsheader.main(['-k', 'NAXIS*', self.data('arange.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 5
+        assert out[1].startswith('NAXIS')
+        assert out[2].startswith('NAXIS1')
+        assert out[3].startswith('NAXIS2')
+        assert out[4].startswith('NAXIS3')
+
+        fitsheader.main(['-k', 'RANDOMKEY', self.data('arange.fits')])
+        out, err = capsys.readouterr()
+        assert err.startswith('WARNING') and 'RANDOMKEY' in err
+        assert not err.startswith('ERROR')
+
+    def test_by_extension(self, capsys):
+        fitsheader.main(['-e', '1', self.data('test0.fits')])
+        out, err = capsys.readouterr()
+        assert len(out.splitlines()) == 62
+
+        fitsheader.main(['-e', '3', '-k', 'BACKGRND', self.data('test0.fits')])
+        out, err = capsys.readouterr()
+        assert out.splitlines()[1].startswith('BACKGRND=                 312.')
+
+        fitsheader.main(['-e', '0', '-k', 'BACKGRND', self.data('test0.fits')])
+        out, err = capsys.readouterr()
+        assert err.startswith('WARNING')
+
+        fitsheader.main(['-e', '3', '-k', 'FOO', self.data('test0.fits')])
+        out, err = capsys.readouterr()
+        assert err.startswith('WARNING')
+
+    def test_table(self, capsys):
+        fitsheader.main(['-t', '-k', 'BACKGRND', self.data('test0.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 5
+        assert out[1].endswith('|   1 | BACKGRND | 316.0 |')
+        assert out[2].endswith('|   2 | BACKGRND | 351.0 |')
+        assert out[3].endswith('|   3 | BACKGRND | 312.0 |')
+        assert out[4].endswith('|   4 | BACKGRND | 323.0 |')
+
+        fitsheader.main(['-t', '-e', '0', '-k', 'NAXIS',
+                         self.data('arange.fits'),
+                         self.data('ascii.fits'),
+                         self.data('blank.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 4
+        assert out[1].endswith('|   0 |   NAXIS |     3 |')
+        assert out[2].endswith('|   0 |   NAXIS |     0 |')
+        assert out[3].endswith('|   0 |   NAXIS |     2 |')
+
+    def test_fitsort(self, capsys):
+        fitsheader.main(['-e', '0', '-f', '-k', 'EXPSTART', '-k', 'EXPTIME',
+                         self.data('test0.fits'), self.data('test1.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 4
+        assert out[2].endswith('test0.fits 49491.65366175    0.23')
+        assert out[3].endswith('test1.fits 49492.65366175    0.22')
+
+        fitsheader.main(['-e', '0', '-f', '-k', 'EXPSTART', '-k', 'EXPTIME',
+                         self.data('test0.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 3
+        assert out[2].endswith('test0.fits 49491.65366175    0.23')
+
+        fitsheader.main(['-f', '-k', 'NAXIS',
+                         self.data('tdim.fits'), self.data('test1.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 4
+        assert out[0].endswith('0:NAXIS 1:NAXIS 2:NAXIS 3:NAXIS 4:NAXIS')
+        assert out[2].endswith('tdim.fits       0       2      --      --      --')
+        assert out[3].endswith('test1.fits       0       2       2       2       2')
+
+        # check that files without required keyword are present
+        fitsheader.main(['-f', '-k', 'DATE-OBS',
+                         self.data('table.fits'), self.data('test0.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 4
+        assert out[2].endswith('table.fits       --')
+        assert out[3].endswith('test0.fits 19/05/94')
+
+        # check that COMMENT and HISTORY are excluded
+        fitsheader.main(['-e', '0', '-f', self.data('tb.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 3
+        assert out[2].endswith('tb.fits   True     16     0   True '
+                               'STScI-STSDAS/TABLES  tb.fits       1')
+
+    def test_dotkeyword(self, capsys):
+        fitsheader.main(['-e', '0', '-k', 'ESO DET ID',
+                         self.data('fixed-1890.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 2
+        assert out[1].strip().endswith("HIERARCH ESO DET ID = 'DV13' / Detector system Id")
+
+        fitsheader.main(['-e', '0', '-k', 'ESO.DET.ID',
+                         self.data('fixed-1890.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 2
+        assert out[1].strip().endswith("HIERARCH ESO DET ID = 'DV13' / Detector system Id")

testbed/astropy__astropy/astropy/io/fits/tests/test_fitsinfo.py

@@ -0,0 +1,31 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+from . import FitsTestCase
+from astropy.io.fits.scripts import fitsinfo
+
+
+class TestFitsinfo(FitsTestCase):
+
+    def test_onefile(self, capsys):
+        fitsinfo.main([self.data('arange.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 3
+        assert out[1].startswith(
+            'No.    Name      Ver    Type      Cards   Dimensions   Format')
+        assert out[2].startswith(
+            '  0  PRIMARY       1 PrimaryHDU       7   (11, 10, 7)   int32')
+
+    def test_multiplefiles(self, capsys):
+        fitsinfo.main([self.data('arange.fits'),
+                       self.data('ascii.fits')])
+        out, err = capsys.readouterr()
+        out = out.splitlines()
+        assert len(out) == 8
+        assert out[1].startswith(
+            'No.    Name      Ver    Type      Cards   Dimensions   Format')
+        assert out[2].startswith(
+            '  0  PRIMARY       1 PrimaryHDU       7   (11, 10, 7)   int32')
+        assert out[3] == ''
+        assert out[7].startswith(
+            '  1                1 TableHDU        20   5R x 2C   [E10.4, I5]')

testbed/astropy__astropy/astropy/io/fits/tests/test_fitstime.py

@@ -0,0 +1,440 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+import pytest
+import numpy as np
+
+from . import FitsTestCase
+
+from astropy.io.fits.fitstime import GLOBAL_TIME_INFO, time_to_fits, is_time_column_keyword
+from astropy.coordinates import EarthLocation
+from astropy.io import fits
+from astropy.table import Table, QTable
+from astropy.time import Time, TimeDelta
+from astropy.time.core import BARYCENTRIC_SCALES
+from astropy.time.formats import FITS_DEPRECATED_SCALES
+from astropy.tests.helper import catch_warnings
+from astropy.utils.exceptions import AstropyUserWarning, AstropyDeprecationWarning
+
+
+class TestFitsTime(FitsTestCase):
+
+    def setup_class(self):
+        self.time = np.array(['1999-01-01T00:00:00.123456789', '2010-01-01T00:00:00'])
+        self.time_3d = np.array([[[1, 2], [1, 3], [3, 4]]])
+
+    def test_is_time_column_keyword(self):
+        # Time column keyword without column number
+        assert is_time_column_keyword('TRPOS') is False
+
+        # Global time column keyword
+        assert is_time_column_keyword('TIMESYS') is False
+
+        # Valid time column keyword
+        assert is_time_column_keyword('TRPOS12') is True
+
+    @pytest.mark.parametrize('table_types', (Table, QTable))
+    def test_time_to_fits_loc(self, table_types):
+        """
+        Test all the unusual conditions for locations of ``Time``
+        columns in a ``Table``.
+        """
+        t = table_types()
+        t['a'] = Time(self.time, format='isot', scale='utc')
+        t['b'] = Time(self.time, format='isot', scale='tt')
+
+        # Check that vectorized location is stored using Green Bank convention
+        t['a'].location = EarthLocation([1., 2.], [2., 3.], [3., 4.],
+                                        unit='Mm')
+
+        with pytest.warns(AstropyUserWarning, match='Time Column "b" has no '
+                          'specified location, but global Time Position is present'):
+            table, hdr = time_to_fits(t)
+        assert (table['OBSGEO-X'] == t['a'].location.x.to_value(unit='m')).all()
+        assert (table['OBSGEO-Y'] == t['a'].location.y.to_value(unit='m')).all()
+        assert (table['OBSGEO-Z'] == t['a'].location.z.to_value(unit='m')).all()
+
+        with pytest.warns(AstropyUserWarning, match='Time Column "b" has no '
+                          'specified location, but global Time Position is present'):
+            t.write(self.temp('time.fits'), format='fits', overwrite=True)
+
+        with pytest.warns(fits.verify.VerifyWarning,
+                          match='Invalid keyword for column 2'):
+            tm = table_types.read(self.temp('time.fits'), format='fits',
+                                  astropy_native=True)
+
+        assert (tm['a'].location == t['a'].location).all()
+        assert tm['b'].location == t['b'].location
+
+        # Check that multiple Time columns with different locations raise an exception
+        t['a'].location = EarthLocation(1, 2, 3)
+        t['b'].location = EarthLocation(2, 3, 4)
+
+        with pytest.raises(ValueError) as err:
+            table, hdr = time_to_fits(t)
+            assert 'Multiple Time Columns with different geocentric' in str(err.value)
+
+        # Check that Time column with no location specified will assume global location
+        t['b'].location = None
+
+        with catch_warnings() as w:
+            table, hdr = time_to_fits(t)
+            assert len(w) == 1
+            assert str(w[0].message).startswith('Time Column "b" has no specified '
+                                                'location, but global Time Position '
+                                                'is present')
+
+        # Check that multiple Time columns with same location can be written
+        t['b'].location = EarthLocation(1, 2, 3)
+
+        with catch_warnings() as w:
+            table, hdr = time_to_fits(t)
+            assert len(w) == 0
+
+        # Check compatibility of Time Scales and Reference Positions
+
+        for scale in BARYCENTRIC_SCALES:
+            t.replace_column('a', getattr(t['a'], scale))
+            with catch_warnings() as w:
+                table, hdr = time_to_fits(t)
+                assert len(w) == 1
+                assert str(w[0].message).startswith('Earth Location "TOPOCENTER" '
+                                                    'for Time Column')
+
+        # Check that multidimensional vectorized location (ndim=3) is stored
+        # using Green Bank convention.
+        t = table_types()
+        location = EarthLocation([[[1., 2.], [1., 3.], [3., 4.]]],
+                                 [[[1., 2.], [1., 3.], [3., 4.]]],
+                                 [[[1., 2.], [1., 3.], [3., 4.]]], unit='Mm')
+        t['a'] = Time(self.time_3d, format='jd', location=location)
+
+        table, hdr = time_to_fits(t)
+        assert (table['OBSGEO-X'] == t['a'].location.x.to_value(unit='m')).all()
+        assert (table['OBSGEO-Y'] == t['a'].location.y.to_value(unit='m')).all()
+        assert (table['OBSGEO-Z'] == t['a'].location.z.to_value(unit='m')).all()
+
+        t.write(self.temp('time.fits'), format='fits', overwrite=True)
+        tm = table_types.read(self.temp('time.fits'), format='fits',
+                              astropy_native=True)
+
+        assert (tm['a'].location == t['a'].location).all()
+
+        # Check that singular location with ndim>1 can be written
+        t['a'] = Time(self.time, location=EarthLocation([[[1.]]], [[[2.]]],
+                                                        [[[3.]]], unit='Mm'))
+
+        table, hdr = time_to_fits(t)
+        assert hdr['OBSGEO-X'] == t['a'].location.x.to_value(unit='m')
+        assert hdr['OBSGEO-Y'] == t['a'].location.y.to_value(unit='m')
+        assert hdr['OBSGEO-Z'] == t['a'].location.z.to_value(unit='m')
+
+        t.write(self.temp('time.fits'), format='fits', overwrite=True)
+        tm = table_types.read(self.temp('time.fits'), format='fits',
+                              astropy_native=True)
+
+        assert tm['a'].location == t['a'].location
+
+    @pytest.mark.parametrize('table_types', (Table, QTable))
+    def test_time_to_fits_header(self, table_types):
+        """
+        Test the header and metadata returned by ``time_to_fits``.
+        """
+        t = table_types()
+        t['a'] = Time(self.time, format='isot', scale='utc',
+                      location=EarthLocation(-2446354,
+                      4237210, 4077985, unit='m'))
+        t['b'] = Time([1,2], format='cxcsec', scale='tt')
+
+        ideal_col_hdr = {'OBSGEO-X' : t['a'].location.x.value,
+                         'OBSGEO-Y' : t['a'].location.y.value,
+                         'OBSGEO-Z' : t['a'].location.z.value}
+
+        with pytest.warns(AstropyUserWarning, match='Time Column "b" has no '
+                          'specified location, but global Time Position is present'):
+            table, hdr = time_to_fits(t)
+
+        # Check the global time keywords in hdr
+        for key, value in GLOBAL_TIME_INFO.items():
+            assert hdr[key] == value[0]
+            assert hdr.comments[key] == value[1]
+            hdr.remove(key)
+
+        for key, value in ideal_col_hdr.items():
+            assert hdr[key] == value
+            hdr.remove(key)
+
+        # Check the column-specific time metadata
+        coord_info = table.meta['__coordinate_columns__']
+        for colname in coord_info:
+            assert coord_info[colname]['coord_type'] == t[colname].scale.upper()
+            assert coord_info[colname]['coord_unit'] == 'd'
+
+        assert coord_info['a']['time_ref_pos'] == 'TOPOCENTER'
+
+        assert len(hdr) == 0
+
+    @pytest.mark.parametrize('table_types', (Table, QTable))
+    def test_fits_to_time_meta(self, table_types):
+        """
+        Test that the relevant global time metadata is read into
+        ``Table.meta`` as ``Time``.
+        """
+        t = table_types()
+        t['a'] = Time(self.time, format='isot', scale='utc')
+        t.meta['DATE'] = '1999-01-01T00:00:00'
+        t.meta['MJD-OBS'] = 56670
+
+        # Test for default write behavior (full precision) and read it
+        # back using native astropy objects; thus, ensure its round-trip
+        t.write(self.temp('time.fits'), format='fits', overwrite=True)
+
+        with pytest.warns(fits.verify.VerifyWarning,
+                          match='Invalid keyword for column 1'):
+            tm = table_types.read(self.temp('time.fits'), format='fits',
+                                  astropy_native=True)
+
+        # Test DATE
+        assert isinstance(tm.meta['DATE'], Time)
+        assert tm.meta['DATE'].value == t.meta['DATE']
+        assert tm.meta['DATE'].format == 'fits'
+        # Default time scale according to the FITS standard is UTC
+        assert tm.meta['DATE'].scale == 'utc'
+
+        # Test MJD-xxx
+        assert isinstance(tm.meta['MJD-OBS'], Time)
+        assert tm.meta['MJD-OBS'].value == t.meta['MJD-OBS']
+        assert tm.meta['MJD-OBS'].format == 'mjd'
+        assert tm.meta['MJD-OBS'].scale == 'utc'
+
+        # Explicitly specified Time Scale
+        t.meta['TIMESYS'] = 'ET'
+
+        t.write(self.temp('time.fits'), format='fits', overwrite=True)
+
+        with pytest.warns(fits.verify.VerifyWarning,
+                          match='Invalid keyword for column 1'):
+            tm = table_types.read(self.temp('time.fits'), format='fits',
+                                  astropy_native=True)
+
+        # Test DATE
+        assert isinstance(tm.meta['DATE'], Time)
+        assert tm.meta['DATE'].value == t.meta['DATE']
+        assert tm.meta['DATE'].scale == 'utc'
+
+        # Test MJD-xxx
+        assert isinstance(tm.meta['MJD-OBS'], Time)
+        assert tm.meta['MJD-OBS'].value == t.meta['MJD-OBS']
+        assert tm.meta['MJD-OBS'].scale == FITS_DEPRECATED_SCALES[t.meta['TIMESYS']]
+
+        # Test for conversion of time data to its value, as defined by its format
+        t['a'].info.serialize_method['fits'] = 'formatted_value'
+        t.write(self.temp('time.fits'), format='fits', overwrite=True)
+        tm = table_types.read(self.temp('time.fits'), format='fits')
+
+        # Test DATE
+        assert not isinstance(tm.meta['DATE'], Time)
+        assert tm.meta['DATE'] == t.meta['DATE']
+
+        # Test MJD-xxx
+        assert not isinstance(tm.meta['MJD-OBS'], Time)
+        assert tm.meta['MJD-OBS'] == t.meta['MJD-OBS']
+
+        assert (tm['a'] == t['a'].value).all()
+
+    @pytest.mark.parametrize('table_types', (Table, QTable))
+    def test_time_loc_unit(self, table_types):
+        """
+        Test that ``location`` specified by using any valid unit
+        (length/angle) in ``Time`` columns gets stored in FITS
+        as ITRS Cartesian coordinates (X, Y, Z), each in m.
+        Test that it round-trips through FITS.
+        """
+        t = table_types()
+        t['a'] = Time(self.time, format='isot', scale='utc',
+                      location=EarthLocation(1,2,3, unit='km'))
+
+        table, hdr = time_to_fits(t)
+
+        # Check the header
+        assert hdr['OBSGEO-X'] == t['a'].location.x.to_value(unit='m')
+        assert hdr['OBSGEO-Y'] == t['a'].location.y.to_value(unit='m')
+        assert hdr['OBSGEO-Z'] == t['a'].location.z.to_value(unit='m')
+
+        t.write(self.temp('time.fits'), format='fits', overwrite=True)
+        tm = table_types.read(self.temp('time.fits'), format='fits',
+                              astropy_native=True)
+
+        # Check the round-trip of location
+        assert (tm['a'].location == t['a'].location).all()
+        assert tm['a'].location.x.value == t['a'].location.x.to_value(unit='m')
+        assert tm['a'].location.y.value == t['a'].location.y.to_value(unit='m')
+        assert tm['a'].location.z.value == t['a'].location.z.to_value(unit='m')
+
+    @pytest.mark.parametrize('table_types', (Table, QTable))
+    def test_io_time_read_fits(self, table_types):
+        """
+        Test that FITS table with time columns (standard compliant)
+        can be read by io.fits as a table with Time columns.
+        This tests the following:
+        1. The special-case where a column has the name 'TIME' and a
+           time unit
+        2. Time from Epoch (Reference time) is appropriately converted.
+        3. Coordinate columns (corresponding to coordinate keywords in the header)
+           other than time, that is, spatial coordinates, are not mistaken
+           to be time.
+        """
+        filename = self.data('chandra_time.fits')
+        with pytest.warns(AstropyUserWarning, match='Time column "time" reference '
+                          'position will be ignored'):
+            tm = table_types.read(filename, astropy_native=True)
+
+        # Test case 1
+        assert isinstance(tm['time'], Time)
+        assert tm['time'].scale == 'tt'
+        assert tm['time'].format == 'mjd'
+
+        non_native = table_types.read(filename)
+
+        # Test case 2
+        ref_time = Time(non_native.meta['MJDREF'], format='mjd',
+                        scale=non_native.meta['TIMESYS'].lower())
+        delta_time = TimeDelta(non_native['time'])
+        assert (ref_time + delta_time == tm['time']).all()
+
+        # Test case 3
+        for colname in ['chipx', 'chipy', 'detx', 'dety', 'x', 'y']:
+            assert not isinstance(tm[colname], Time)
+
+    @pytest.mark.parametrize('table_types', (Table, QTable))
+    def test_io_time_read_fits_datetime(self, table_types):
+        """
+        Test that ISO-8601 Datetime String Columns are read correctly.
+        """
+        # Datetime column
+        c = fits.Column(name='datetime', format='A29', coord_type='TCG',
+                        time_ref_pos='GEOCENTER', array=self.time)
+
+        # Explicitly create a FITS Binary Table
+        bhdu = fits.BinTableHDU.from_columns([c])
+        bhdu.writeto(self.temp('time.fits'), overwrite=True)
+
+        tm = table_types.read(self.temp('time.fits'), astropy_native=True)
+
+        assert isinstance(tm['datetime'], Time)
+        assert tm['datetime'].scale == 'tcg'
+        assert tm['datetime'].format == 'fits'
+        assert (tm['datetime'] == self.time).all()
+
+    @pytest.mark.parametrize('table_types', (Table, QTable))
+    def test_io_time_read_fits_location(self, table_types):
+        """
+        Test that geocentric/geodetic observatory position is read
+        properly, as and when it is specified.
+        """
+        # Datetime column
+        c = fits.Column(name='datetime', format='A29', coord_type='TT',
+                        time_ref_pos='TOPOCENTER', array=self.time)
+
+        # Observatory position in ITRS Cartesian coordinates (geocentric)
+        cards = [('OBSGEO-X', -2446354), ('OBSGEO-Y', 4237210),
+                 ('OBSGEO-Z', 4077985)]
+
+        # Explicitly create a FITS Binary Table
+        bhdu = fits.BinTableHDU.from_columns([c], header=fits.Header(cards))
+        bhdu.writeto(self.temp('time.fits'), overwrite=True)
+
+        tm = table_types.read(self.temp('time.fits'), astropy_native=True)
+
+        assert isinstance(tm['datetime'], Time)
+        assert tm['datetime'].location.x.value == -2446354
+        assert tm['datetime'].location.y.value == 4237210
+        assert tm['datetime'].location.z.value == 4077985
+
+        # Observatory position in geodetic coordinates
+        cards = [('OBSGEO-L', 0), ('OBSGEO-B', 0), ('OBSGEO-H', 0)]
+
+        # Explicitly create a FITS Binary Table
+        bhdu = fits.BinTableHDU.from_columns([c], header=fits.Header(cards))
+        bhdu.writeto(self.temp('time.fits'), overwrite=True)
+
+        tm = table_types.read(self.temp('time.fits'), astropy_native=True)
+
+        assert isinstance(tm['datetime'], Time)
+        assert tm['datetime'].location.lon.value == 0
+        assert tm['datetime'].location.lat.value == 0
+        assert np.isclose(tm['datetime'].location.height.value, 0,
+                          rtol=0, atol=1e-9)
+
+    @pytest.mark.parametrize('table_types', (Table, QTable))
+    def test_io_time_read_fits_scale(self, table_types):
+        """
+        Test handling of 'GPS' and 'LOCAL' time scales which are
+        recognized by the FITS standard but are not native to astropy.
+        """
+        # GPS scale column
+        gps_time = np.array([630720013, 630720014])
+        c = fits.Column(name='gps_time', format='D', unit='s', coord_type='GPS',
+                        coord_unit='s', time_ref_pos='TOPOCENTER', array=gps_time)
+
+        cards = [('OBSGEO-L', 0), ('OBSGEO-B', 0), ('OBSGEO-H', 0)]
+
+        bhdu = fits.BinTableHDU.from_columns([c], header=fits.Header(cards))
+        bhdu.writeto(self.temp('time.fits'), overwrite=True)
+
+        with catch_warnings() as w:
+            tm = table_types.read(self.temp('time.fits'), astropy_native=True)
+            assert len(w) == 1
+            assert 'FITS recognized time scale value "GPS"' in str(w[0].message)
+
+        assert isinstance(tm['gps_time'], Time)
+        assert tm['gps_time'].format == 'gps'
+        assert tm['gps_time'].scale == 'tai'
+        assert (tm['gps_time'].value == gps_time).all()
+
+        # LOCAL scale column
+        local_time = np.array([1, 2])
+        c = fits.Column(name='local_time', format='D', unit='d',
+                        coord_type='LOCAL', coord_unit='d',
+                        time_ref_pos='RELOCATABLE', array=local_time)
+
+        bhdu = fits.BinTableHDU.from_columns([c])
+        bhdu.writeto(self.temp('time.fits'), overwrite=True)
+
+        tm = table_types.read(self.temp('time.fits'), astropy_native=True)
+
+        assert isinstance(tm['local_time'], Time)
+        assert tm['local_time'].format == 'mjd'
+
+        assert tm['local_time'].scale == 'local'
+        assert (tm['local_time'].value == local_time).all()
+
+    @pytest.mark.parametrize('table_types', (Table, QTable))
+    def test_io_time_read_fits_location_warnings(self, table_types):
+        """
+        Test warnings for time column reference position.
+        """
+        # Time reference position "TOPOCENTER" without corresponding
+        # observatory position.
+        c = fits.Column(name='datetime', format='A29', coord_type='TT',
+                        time_ref_pos='TOPOCENTER', array=self.time)
+
+        bhdu = fits.BinTableHDU.from_columns([c])
+        bhdu.writeto(self.temp('time.fits'), overwrite=True)
+
+        with catch_warnings() as w:
+            tm = table_types.read(self.temp('time.fits'), astropy_native=True)
+            assert len(w) == 1
+            assert ('observatory position is not properly specified' in
+                    str(w[0].message))
+
+        # Default value for time reference position is "TOPOCENTER"
+        c = fits.Column(name='datetime', format='A29', coord_type='TT',
+                        array=self.time)
+
+        bhdu = fits.BinTableHDU.from_columns([c])
+        bhdu.writeto(self.temp('time.fits'), overwrite=True)
+        with catch_warnings() as w:
+            tm = table_types.read(self.temp('time.fits'), astropy_native=True)
+            assert len(w) == 1
+            assert ('"TRPOSn" is not specified. The default value for '
+                    'it is "TOPOCENTER"' in str(w[0].message))

testbed/astropy__astropy/astropy/io/fits/tests/test_groups.py

@@ -0,0 +1,211 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+import os
+import time
+
+import pytest
+import numpy as np
+
+from . import FitsTestCase
+from .test_table import comparerecords
+from astropy.io import fits
+
+
+class TestGroupsFunctions(FitsTestCase):
+    def test_open(self):
+        with fits.open(self.data('random_groups.fits')) as hdul:
+            assert isinstance(hdul[0], fits.GroupsHDU)
+            naxes = (3, 1, 128, 1, 1)
+            parameters = ['UU', 'VV', 'WW', 'BASELINE', 'DATE']
+            info = [(0, 'PRIMARY', 1, 'GroupsHDU', 147, naxes, 'float32',
+                     '3 Groups  5 Parameters')]
+            assert hdul.info(output=False) == info
+
+            ghdu = hdul[0]
+            assert ghdu.parnames == parameters
+            assert list(ghdu.data.dtype.names) == parameters + ['DATA']
+
+            assert isinstance(ghdu.data, fits.GroupData)
+            # The data should be equal to the number of groups
+            assert ghdu.header['GCOUNT'] == len(ghdu.data)
+            assert ghdu.data.data.shape == (len(ghdu.data),) + naxes[::-1]
+            assert ghdu.data.parnames == parameters
+
+            assert isinstance(ghdu.data[0], fits.Group)
+            assert len(ghdu.data[0]) == len(parameters) + 1
+            assert ghdu.data[0].data.shape == naxes[::-1]
+            assert ghdu.data[0].parnames == parameters
+
+    def test_open_groups_in_update_mode(self):
+        """
+        Test that opening a file containing a groups HDU in update mode and
+        then immediately closing it does not result in any unnecessary file
+        modifications.
+
+        Similar to
+        test_image.TestImageFunctions.test_open_scaled_in_update_mode().
+        """
+
+        # Copy the original file before making any possible changes to it
+        self.copy_file('random_groups.fits')
+        mtime = os.stat(self.temp('random_groups.fits')).st_mtime
+
+        time.sleep(1)
+
+        fits.open(self.temp('random_groups.fits'), mode='update',
+                  memmap=False).close()
+
+        # Ensure that no changes were made to the file merely by immediately
+        # opening and closing it.
+        assert mtime == os.stat(self.temp('random_groups.fits')).st_mtime
+
+    def test_random_groups_data_update(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/3730 and
+        for https://github.com/spacetelescope/PyFITS/issues/102
+        """
+
+        self.copy_file('random_groups.fits')
+        with fits.open(self.temp('random_groups.fits'), mode='update') as h:
+            h[0].data['UU'] = 0.42
+
+        with fits.open(self.temp('random_groups.fits'), mode='update') as h:
+            assert np.all(h[0].data['UU'] == 0.42)
+
+    def test_parnames_round_trip(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/130
+
+        Ensures that opening a random groups file in update mode or writing it
+        to a new file does not cause any change to the parameter names.
+        """
+
+        # Because this test tries to update the random_groups.fits file, let's
+        # make a copy of it first (so that the file doesn't actually get
+        # modified in the off chance that the test fails
+        self.copy_file('random_groups.fits')
+
+        parameters = ['UU', 'VV', 'WW', 'BASELINE', 'DATE']
+        with fits.open(self.temp('random_groups.fits'), mode='update') as h:
+            assert h[0].parnames == parameters
+            h.flush()
+        # Open again just in read-only mode to ensure the parnames didn't
+        # change
+        with fits.open(self.temp('random_groups.fits')) as h:
+            assert h[0].parnames == parameters
+            h.writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits')) as h:
+            assert h[0].parnames == parameters
+
+    def test_groupdata_slice(self):
+        """
+        A simple test to ensure that slicing GroupData returns a new, smaller
+        GroupData object, as is the case with a normal FITS_rec.  This is a
+        regression test for an as-of-yet unreported issue where slicing
+        GroupData returned a single Group record.
+        """
+
+        with fits.open(self.data('random_groups.fits')) as hdul:
+            s = hdul[0].data[1:]
+            assert isinstance(s, fits.GroupData)
+            assert len(s) == 2
+            assert hdul[0].data.parnames == s.parnames
+
+    def test_group_slice(self):
+        """
+        Tests basic slicing a single group record.
+        """
+
+        # A very basic slice test
+        with fits.open(self.data('random_groups.fits')) as hdul:
+            g = hdul[0].data[0]
+            s = g[2:4]
+            assert len(s) == 2
+            assert s[0] == g[2]
+            assert s[-1] == g[-3]
+            s = g[::-1]
+            assert len(s) == 6
+            assert (s[0] == g[-1]).all()
+            assert s[-1] == g[0]
+            s = g[::2]
+            assert len(s) == 3
+            assert s[0] == g[0]
+            assert s[1] == g[2]
+            assert s[2] == g[4]
+
+    def test_create_groupdata(self):
+        """
+        Basic test for creating GroupData from scratch.
+        """
+
+        imdata = np.arange(100.0)
+        imdata.shape = (10, 1, 1, 2, 5)
+        pdata1 = np.arange(10, dtype=np.float32) + 0.1
+        pdata2 = 42.0
+        x = fits.hdu.groups.GroupData(imdata, parnames=['abc', 'xyz'],
+                                      pardata=[pdata1, pdata2], bitpix=-32)
+        assert x.parnames == ['abc', 'xyz']
+        assert (x.par('abc') == pdata1).all()
+        assert (x.par('xyz') == ([pdata2] * len(x))).all()
+        assert (x.data == imdata).all()
+
+        # Test putting the data into a GroupsHDU and round-tripping it
+        ghdu = fits.GroupsHDU(data=x)
+        ghdu.writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits')) as h:
+            hdr = h[0].header
+            assert hdr['GCOUNT'] == 10
+            assert hdr['PCOUNT'] == 2
+            assert hdr['NAXIS'] == 5
+            assert hdr['NAXIS1'] == 0
+            assert hdr['NAXIS2'] == 5
+            assert hdr['NAXIS3'] == 2
+            assert hdr['NAXIS4'] == 1
+            assert hdr['NAXIS5'] == 1
+            assert h[0].data.parnames == ['abc', 'xyz']
+            assert comparerecords(h[0].data, x)
+
+    def test_duplicate_parameter(self):
+        """
+        Tests support for multiple parameters of the same name, and ensures
+        that the data in duplicate parameters are returned as a single summed
+        value.
+        """
+
+        imdata = np.arange(100.0)
+        imdata.shape = (10, 1, 1, 2, 5)
+        pdata1 = np.arange(10, dtype=np.float32) + 1
+        pdata2 = 42.0
+        x = fits.hdu.groups.GroupData(imdata, parnames=['abc', 'xyz', 'abc'],
+                                      pardata=[pdata1, pdata2, pdata1],
+                                      bitpix=-32)
+
+        assert x.parnames == ['abc', 'xyz', 'abc']
+        assert (x.par('abc') == pdata1 * 2).all()
+        assert x[0].par('abc') == 2
+
+        # Test setting a parameter
+        x[0].setpar(0, 2)
+        assert x[0].par('abc') == 3
+        pytest.raises(ValueError, x[0].setpar, 'abc', 2)
+        x[0].setpar('abc', (2, 3))
+        assert x[0].par('abc') == 5
+        assert x.par('abc')[0] == 5
+        assert (x.par('abc')[1:] == pdata1[1:] * 2).all()
+
+        # Test round-trip
+        ghdu = fits.GroupsHDU(data=x)
+        ghdu.writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits')) as h:
+            hdr = h[0].header
+            assert hdr['PCOUNT'] == 3
+            assert hdr['PTYPE1'] == 'abc'
+            assert hdr['PTYPE2'] == 'xyz'
+            assert hdr['PTYPE3'] == 'abc'
+            assert x.parnames == ['abc', 'xyz', 'abc']
+            assert x.dtype.names == ('abc', 'xyz', '_abc', 'DATA')
+            assert x.par('abc')[0] == 5
+            assert (x.par('abc')[1:] == pdata1[1:] * 2).all()

testbed/astropy__astropy/astropy/io/fits/tests/test_hdulist.py

@@ -0,0 +1,1055 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import glob
+import io
+import os
+import platform
+import sys
+import copy
+import subprocess
+
+import pytest
+import numpy as np
+
+from astropy.io.fits.verify import VerifyError
+from astropy.io import fits
+from astropy.tests.helper import raises, catch_warnings, ignore_warnings
+from astropy.utils.exceptions import AstropyUserWarning, AstropyDeprecationWarning
+
+from . import FitsTestCase
+
+
+class TestHDUListFunctions(FitsTestCase):
+    def test_update_name(self):
+        with fits.open(self.data('o4sp040b0_raw.fits')) as hdul:
+            hdul[4].name = 'Jim'
+            hdul[4].ver = 9
+            assert hdul[('JIM', 9)].header['extname'] == 'JIM'
+
+    def test_hdu_file_bytes(self):
+        with fits.open(self.data('checksum.fits')) as hdul:
+            res = hdul[0].filebytes()
+            assert res == 11520
+            res = hdul[1].filebytes()
+            assert res == 8640
+
+    def test_hdulist_file_info(self):
+        def test_fileinfo(**kwargs):
+            assert res['datSpan'] == kwargs.get('datSpan', 2880)
+            assert res['resized'] == kwargs.get('resized', False)
+            assert res['filename'] == self.data('checksum.fits')
+            assert res['datLoc'] == kwargs.get('datLoc', 8640)
+            assert res['hdrLoc'] == kwargs.get('hdrLoc', 0)
+            assert res['filemode'] == 'readonly'
+
+        with fits.open(self.data('checksum.fits')) as hdul:
+            res = hdul.fileinfo(0)
+
+            res = hdul.fileinfo(1)
+            test_fileinfo(datLoc=17280, hdrLoc=11520)
+
+            hdu = fits.ImageHDU(data=hdul[0].data)
+            hdul.insert(1, hdu)
+
+            res = hdul.fileinfo(0)
+            test_fileinfo(resized=True)
+
+            res = hdul.fileinfo(1)
+            test_fileinfo(datSpan=None, resized=True, datLoc=None, hdrLoc=None)
+
+            res = hdul.fileinfo(2)
+            test_fileinfo(resized=1, datLoc=17280, hdrLoc=11520)
+
+    def test_create_from_multiple_primary(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/145
+
+        Ensure that a validation error occurs when saving an HDUList containing
+        multiple PrimaryHDUs.
+        """
+
+        hdul = fits.HDUList([fits.PrimaryHDU(), fits.PrimaryHDU()])
+        pytest.raises(VerifyError, hdul.writeto, self.temp('temp.fits'),
+                      output_verify='exception')
+
+    def test_append_primary_to_empty_list(self):
+        # Tests appending a Simple PrimaryHDU to an empty HDUList.
+        hdul = fits.HDUList()
+        hdu = fits.PrimaryHDU(np.arange(100, dtype=np.int32))
+        hdul.append(hdu)
+        info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 5, (100,), 'int32', '')]
+        assert hdul.info(output=False) == info
+
+        hdul.writeto(self.temp('test-append.fits'))
+
+        assert fits.info(self.temp('test-append.fits'), output=False) == info
+
+    def test_append_extension_to_empty_list(self):
+        """Tests appending a Simple ImageHDU to an empty HDUList."""
+
+        hdul = fits.HDUList()
+        hdu = fits.ImageHDU(np.arange(100, dtype=np.int32))
+        hdul.append(hdu)
+        info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 4, (100,), 'int32', '')]
+        assert hdul.info(output=False) == info
+
+        hdul.writeto(self.temp('test-append.fits'))
+
+        assert fits.info(self.temp('test-append.fits'), output=False) == info
+
+    def test_append_table_extension_to_empty_list(self):
+        """Tests appending a Simple Table ExtensionHDU to a empty HDUList."""
+
+        hdul = fits.HDUList()
+        with fits.open(self.data('tb.fits')) as hdul1:
+            hdul.append(hdul1[1])
+            info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 4, (), '', ''),
+                    (1, '', 1, 'BinTableHDU', 24, '2R x 4C', '[1J, 3A, 1E, 1L]', '')]
+
+            assert hdul.info(output=False) == info
+
+            hdul.writeto(self.temp('test-append.fits'))
+
+        assert fits.info(self.temp('test-append.fits'), output=False) == info
+
+    def test_append_groupshdu_to_empty_list(self):
+        """Tests appending a Simple GroupsHDU to an empty HDUList."""
+
+        hdul = fits.HDUList()
+        hdu = fits.GroupsHDU()
+        hdul.append(hdu)
+
+        info = [(0, 'PRIMARY', 1, 'GroupsHDU', 8, (), '',
+                 '1 Groups  0 Parameters')]
+
+        assert hdul.info(output=False) == info
+
+        hdul.writeto(self.temp('test-append.fits'))
+
+        assert fits.info(self.temp('test-append.fits'), output=False) == info
+
+    def test_append_primary_to_non_empty_list(self):
+        """Tests appending a Simple PrimaryHDU to a non-empty HDUList."""
+
+        with fits.open(self.data('arange.fits')) as hdul:
+            hdu = fits.PrimaryHDU(np.arange(100, dtype=np.int32))
+            hdul.append(hdu)
+
+            info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 7, (11, 10, 7), 'int32', ''),
+                    (1, '', 1, 'ImageHDU', 6, (100,), 'int32', '')]
+
+            assert hdul.info(output=False) == info
+
+            hdul.writeto(self.temp('test-append.fits'))
+
+        assert fits.info(self.temp('test-append.fits'), output=False) == info
+
+    def test_append_extension_to_non_empty_list(self):
+        """Tests appending a Simple ExtensionHDU to a non-empty HDUList."""
+
+        with fits.open(self.data('tb.fits')) as hdul:
+            hdul.append(hdul[1])
+
+            info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 11, (), '', ''),
+                    (1, '', 1, 'BinTableHDU', 24, '2R x 4C', '[1J, 3A, 1E, 1L]', ''),
+                    (2, '', 1, 'BinTableHDU', 24, '2R x 4C', '[1J, 3A, 1E, 1L]', '')]
+
+            assert hdul.info(output=False) == info
+
+            hdul.writeto(self.temp('test-append.fits'))
+
+        assert fits.info(self.temp('test-append.fits'), output=False) == info
+
+    @raises(ValueError)
+    def test_append_groupshdu_to_non_empty_list(self):
+        """Tests appending a Simple GroupsHDU to an empty HDUList."""
+
+        hdul = fits.HDUList()
+        hdu = fits.PrimaryHDU(np.arange(100, dtype=np.int32))
+        hdul.append(hdu)
+        hdu = fits.GroupsHDU()
+        hdul.append(hdu)
+
+    def test_insert_primary_to_empty_list(self):
+        """Tests inserting a Simple PrimaryHDU to an empty HDUList."""
+        hdul = fits.HDUList()
+        hdu = fits.PrimaryHDU(np.arange(100, dtype=np.int32))
+        hdul.insert(0, hdu)
+
+        info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 5, (100,), 'int32', '')]
+
+        assert hdul.info(output=False) == info
+
+        hdul.writeto(self.temp('test-insert.fits'))
+
+        assert fits.info(self.temp('test-insert.fits'), output=False) == info
+
+    def test_insert_extension_to_empty_list(self):
+        """Tests inserting a Simple ImageHDU to an empty HDUList."""
+
+        hdul = fits.HDUList()
+        hdu = fits.ImageHDU(np.arange(100, dtype=np.int32))
+        hdul.insert(0, hdu)
+
+        info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 4, (100,), 'int32', '')]
+
+        assert hdul.info(output=False) == info
+
+        hdul.writeto(self.temp('test-insert.fits'))
+
+        assert fits.info(self.temp('test-insert.fits'), output=False) == info
+
+    def test_insert_table_extension_to_empty_list(self):
+        """Tests inserting a Simple Table ExtensionHDU to a empty HDUList."""
+
+        hdul = fits.HDUList()
+        with fits.open(self.data('tb.fits')) as hdul1:
+            hdul.insert(0, hdul1[1])
+
+            info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 4, (), '', ''),
+                    (1, '', 1, 'BinTableHDU', 24, '2R x 4C', '[1J, 3A, 1E, 1L]', '')]
+
+            assert hdul.info(output=False) == info
+
+            hdul.writeto(self.temp('test-insert.fits'))
+
+        assert fits.info(self.temp('test-insert.fits'), output=False) == info
+
+    def test_insert_groupshdu_to_empty_list(self):
+        """Tests inserting a Simple GroupsHDU to an empty HDUList."""
+
+        hdul = fits.HDUList()
+        hdu = fits.GroupsHDU()
+        hdul.insert(0, hdu)
+
+        info = [(0, 'PRIMARY', 1, 'GroupsHDU', 8, (), '',
+                 '1 Groups  0 Parameters')]
+
+        assert hdul.info(output=False) == info
+
+        hdul.writeto(self.temp('test-insert.fits'))
+
+        assert fits.info(self.temp('test-insert.fits'), output=False) == info
+
+    def test_insert_primary_to_non_empty_list(self):
+        """Tests inserting a Simple PrimaryHDU to a non-empty HDUList."""
+
+        with fits.open(self.data('arange.fits')) as hdul:
+            hdu = fits.PrimaryHDU(np.arange(100, dtype=np.int32))
+            hdul.insert(1, hdu)
+
+            info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 7, (11, 10, 7), 'int32', ''),
+                    (1, '', 1, 'ImageHDU', 6, (100,), 'int32', '')]
+
+            assert hdul.info(output=False) == info
+
+            hdul.writeto(self.temp('test-insert.fits'))
+
+        assert fits.info(self.temp('test-insert.fits'), output=False) == info
+
+    def test_insert_extension_to_non_empty_list(self):
+        """Tests inserting a Simple ExtensionHDU to a non-empty HDUList."""
+
+        with fits.open(self.data('tb.fits')) as hdul:
+            hdul.insert(1, hdul[1])
+
+            info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 11, (), '', ''),
+                    (1, '', 1, 'BinTableHDU', 24, '2R x 4C', '[1J, 3A, 1E, 1L]', ''),
+                    (2, '', 1, 'BinTableHDU', 24, '2R x 4C', '[1J, 3A, 1E, 1L]', '')]
+
+            assert hdul.info(output=False) == info
+
+            hdul.writeto(self.temp('test-insert.fits'))
+
+        assert fits.info(self.temp('test-insert.fits'), output=False) == info
+
+    def test_insert_groupshdu_to_non_empty_list(self):
+        """Tests inserting a Simple GroupsHDU to an empty HDUList."""
+
+        hdul = fits.HDUList()
+        hdu = fits.PrimaryHDU(np.arange(100, dtype=np.int32))
+        hdul.insert(0, hdu)
+        hdu = fits.GroupsHDU()
+
+        with pytest.raises(ValueError):
+            hdul.insert(1, hdu)
+
+        info = [(0, 'PRIMARY', 1, 'GroupsHDU', 8, (), '',
+                 '1 Groups  0 Parameters'),
+                (1, '', 1, 'ImageHDU', 6, (100,), 'int32', '')]
+
+        hdul.insert(0, hdu)
+
+        assert hdul.info(output=False) == info
+
+        hdul.writeto(self.temp('test-insert.fits'))
+
+        assert fits.info(self.temp('test-insert.fits'), output=False) == info
+
+    @raises(ValueError)
+    def test_insert_groupshdu_to_begin_of_hdulist_with_groupshdu(self):
+        """
+        Tests inserting a Simple GroupsHDU to the beginning of an HDUList
+        that that already contains a GroupsHDU.
+        """
+
+        hdul = fits.HDUList()
+        hdu = fits.GroupsHDU()
+        hdul.insert(0, hdu)
+        hdul.insert(0, hdu)
+
+    def test_insert_extension_to_primary_in_non_empty_list(self):
+        # Tests inserting a Simple ExtensionHDU to a non-empty HDUList.
+        with fits.open(self.data('tb.fits')) as hdul:
+            hdul.insert(0, hdul[1])
+
+            info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 4, (), '', ''),
+                    (1, '', 1, 'BinTableHDU', 24, '2R x 4C', '[1J, 3A, 1E, 1L]', ''),
+                    (2, '', 1, 'ImageHDU', 12, (), '', ''),
+                    (3, '', 1, 'BinTableHDU', 24, '2R x 4C', '[1J, 3A, 1E, 1L]', '')]
+
+            assert hdul.info(output=False) == info
+
+            hdul.writeto(self.temp('test-insert.fits'))
+
+        assert fits.info(self.temp('test-insert.fits'), output=False) == info
+
+    def test_insert_image_extension_to_primary_in_non_empty_list(self):
+        """
+        Tests inserting a Simple Image ExtensionHDU to a non-empty HDUList
+        as the primary HDU.
+        """
+
+        with fits.open(self.data('tb.fits')) as hdul:
+            hdu = fits.ImageHDU(np.arange(100, dtype=np.int32))
+            hdul.insert(0, hdu)
+
+            info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 5, (100,), 'int32', ''),
+                    (1, '', 1, 'ImageHDU', 12, (), '', ''),
+                    (2, '', 1, 'BinTableHDU', 24, '2R x 4C', '[1J, 3A, 1E, 1L]', '')]
+
+            assert hdul.info(output=False) == info
+
+            hdul.writeto(self.temp('test-insert.fits'))
+
+        assert fits.info(self.temp('test-insert.fits'), output=False) == info
+
+    def test_filename(self):
+        """Tests the HDUList filename method."""
+
+        with fits.open(self.data('tb.fits')) as hdul:
+            name = hdul.filename()
+        assert name == self.data('tb.fits')
+
+    def test_file_like(self):
+        """
+        Tests the use of a file like object with no tell or seek methods
+        in HDUList.writeto(), HDULIST.flush() or astropy.io.fits.writeto()
+        """
+
+        hdu = fits.PrimaryHDU(np.arange(100, dtype=np.int32))
+        hdul = fits.HDUList()
+        hdul.append(hdu)
+        tmpfile = open(self.temp('tmpfile.fits'), 'wb')
+        hdul.writeto(tmpfile)
+        tmpfile.close()
+
+        info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 5, (100,), 'int32', '')]
+
+        assert fits.info(self.temp('tmpfile.fits'), output=False) == info
+
+    def test_file_like_2(self):
+        hdu = fits.PrimaryHDU(np.arange(100, dtype=np.int32))
+        tmpfile = open(self.temp('tmpfile.fits'), 'wb')
+        hdul = fits.open(tmpfile, mode='ostream')
+        hdul.append(hdu)
+        hdul.flush()
+        tmpfile.close()
+        hdul.close()
+
+        info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 5, (100,), 'int32', '')]
+        assert fits.info(self.temp('tmpfile.fits'), output=False) == info
+
+    def test_file_like_3(self):
+        tmpfile = open(self.temp('tmpfile.fits'), 'wb')
+        fits.writeto(tmpfile, np.arange(100, dtype=np.int32))
+        tmpfile.close()
+        info = [(0, 'PRIMARY', 1, 'PrimaryHDU', 5, (100,), 'int32', '')]
+        assert fits.info(self.temp('tmpfile.fits'), output=False) == info
+
+    def test_shallow_copy(self):
+        """
+        Tests that `HDUList.__copy__()` and `HDUList.copy()` return a
+        shallow copy (regression test for #7211).
+        """
+
+        n = np.arange(10.0)
+        primary_hdu = fits.PrimaryHDU(n)
+        hdu = fits.ImageHDU(n)
+        hdul = fits.HDUList([primary_hdu, hdu])
+
+        for hdulcopy in (hdul.copy(), copy.copy(hdul)):
+            assert isinstance(hdulcopy, fits.HDUList)
+            assert hdulcopy is not hdul
+            assert hdulcopy[0] is hdul[0]
+            assert hdulcopy[1] is hdul[1]
+
+    def test_deep_copy(self):
+        """
+        Tests that `HDUList.__deepcopy__()` returns a deep copy.
+        """
+
+        n = np.arange(10.0)
+        primary_hdu = fits.PrimaryHDU(n)
+        hdu = fits.ImageHDU(n)
+        hdul = fits.HDUList([primary_hdu, hdu])
+
+        hdulcopy = copy.deepcopy(hdul)
+
+        assert isinstance(hdulcopy, fits.HDUList)
+        assert hdulcopy is not hdul
+
+        for index in range(len(hdul)):
+            assert hdulcopy[index] is not hdul[index]
+            assert hdulcopy[index].header == hdul[index].header
+            np.testing.assert_array_equal(hdulcopy[index].data, hdul[index].data)
+
+    def test_new_hdu_extname(self):
+        """
+        Tests that new extension HDUs that are added to an HDUList can be
+        properly indexed by their EXTNAME/EXTVER (regression test for
+        ticket:48).
+        """
+
+        with fits.open(self.data('test0.fits')) as f:
+            hdul = fits.HDUList()
+            hdul.append(f[0].copy())
+            hdu = fits.ImageHDU(header=f[1].header)
+            hdul.append(hdu)
+
+        assert hdul[1].header['EXTNAME'] == 'SCI'
+        assert hdul[1].header['EXTVER'] == 1
+        assert hdul.index_of(('SCI', 1)) == 1
+        assert hdul.index_of(hdu) == len(hdul) - 1
+
+    def test_update_filelike(self):
+        """Test opening a file-like object in update mode and resizing the
+        HDU.
+        """
+
+        sf = io.BytesIO()
+        arr = np.zeros((100, 100))
+        hdu = fits.PrimaryHDU(data=arr)
+        hdu.writeto(sf)
+
+        sf.seek(0)
+        arr = np.zeros((200, 200))
+        hdul = fits.open(sf, mode='update')
+        hdul[0].data = arr
+        hdul.flush()
+
+        sf.seek(0)
+        hdul = fits.open(sf)
+        assert len(hdul) == 1
+        assert (hdul[0].data == arr).all()
+
+    def test_flush_readonly(self):
+        """Test flushing changes to a file opened in a read only mode."""
+
+        oldmtime = os.stat(self.data('test0.fits')).st_mtime
+        hdul = fits.open(self.data('test0.fits'))
+        hdul[0].header['FOO'] = 'BAR'
+        with catch_warnings(AstropyUserWarning) as w:
+            hdul.flush()
+        assert len(w) == 1
+        assert 'mode is not supported' in str(w[0].message)
+        assert oldmtime == os.stat(self.data('test0.fits')).st_mtime
+
+    def test_fix_extend_keyword(self):
+        hdul = fits.HDUList()
+        hdul.append(fits.PrimaryHDU())
+        hdul.append(fits.ImageHDU())
+        del hdul[0].header['EXTEND']
+        hdul.verify('silentfix')
+
+        assert 'EXTEND' in hdul[0].header
+        assert hdul[0].header['EXTEND'] is True
+
+    def test_fix_malformed_naxisj(self):
+        """
+        Tests that malformed NAXISj values are fixed sensibly.
+        """
+
+        hdu = fits.open(self.data('arange.fits'))
+
+        # Malform NAXISj header data
+        hdu[0].header['NAXIS1'] = 11.0
+        hdu[0].header['NAXIS2'] = '10.0'
+        hdu[0].header['NAXIS3'] = '7'
+
+        # Axes cache needs to be malformed as well
+        hdu[0]._axes = [11.0, '10.0', '7']
+
+        # Perform verification including the fix
+        hdu.verify('silentfix')
+
+        # Check that malformed data was converted
+        assert hdu[0].header['NAXIS1'] == 11
+        assert hdu[0].header['NAXIS2'] == 10
+        assert hdu[0].header['NAXIS3'] == 7
+        hdu.close()
+
+    def test_fix_wellformed_naxisj(self):
+        """
+        Tests that wellformed NAXISj values are not modified.
+        """
+
+        hdu = fits.open(self.data('arange.fits'))
+
+        # Fake new NAXISj header data
+        hdu[0].header['NAXIS1'] = 768
+        hdu[0].header['NAXIS2'] = 64
+        hdu[0].header['NAXIS3'] = 8
+
+        # Axes cache needs to be faked as well
+        hdu[0]._axes = [768, 64, 8]
+
+        # Perform verification including the fix
+        hdu.verify('silentfix')
+
+        # Check that malformed data was converted
+        assert hdu[0].header['NAXIS1'] == 768
+        assert hdu[0].header['NAXIS2'] == 64
+        assert hdu[0].header['NAXIS3'] == 8
+        hdu.close()
+
+    def test_new_hdulist_extend_keyword(self):
+        """Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/114
+
+        Tests that adding a PrimaryHDU to a new HDUList object updates the
+        EXTEND keyword on that HDU.
+        """
+
+        h0 = fits.Header()
+        hdu = fits.PrimaryHDU(header=h0)
+        sci = fits.ImageHDU(data=np.array(10))
+        image = fits.HDUList([hdu, sci])
+        image.writeto(self.temp('temp.fits'))
+        assert 'EXTEND' in hdu.header
+        assert hdu.header['EXTEND'] is True
+
+    def test_replace_memmaped_array(self):
+        # Copy the original before we modify it
+        with fits.open(self.data('test0.fits')) as hdul:
+            hdul.writeto(self.temp('temp.fits'))
+
+        hdul = fits.open(self.temp('temp.fits'), mode='update', memmap=True)
+        old_data = hdul[1].data.copy()
+        hdul[1].data = hdul[1].data + 1
+        hdul.close()
+
+        with fits.open(self.temp('temp.fits'), memmap=True) as hdul:
+            assert ((old_data + 1) == hdul[1].data).all()
+
+    def test_open_file_with_end_padding(self):
+        """Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/106
+
+        Open files with end padding bytes.
+        """
+
+        with fits.open(self.data('test0.fits'),
+                       do_not_scale_image_data=True) as hdul:
+            info = hdul.info(output=False)
+            hdul.writeto(self.temp('temp.fits'))
+
+        with open(self.temp('temp.fits'), 'ab') as f:
+            f.seek(0, os.SEEK_END)
+            f.write(b'\0' * 2880)
+        with ignore_warnings():
+            assert info == fits.info(self.temp('temp.fits'), output=False,
+                                     do_not_scale_image_data=True)
+
+    def test_open_file_with_bad_header_padding(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/136
+
+        Open files with nulls for header block padding instead of spaces.
+        """
+
+        a = np.arange(100).reshape(10, 10)
+        hdu = fits.PrimaryHDU(data=a)
+        hdu.writeto(self.temp('temp.fits'))
+
+        # Figure out where the header padding begins and fill it with nulls
+        end_card_pos = str(hdu.header).index('END' + ' ' * 77)
+        padding_start = end_card_pos + 80
+        padding_len = 2880 - padding_start
+        with open(self.temp('temp.fits'), 'r+b') as f:
+            f.seek(padding_start)
+            f.write('\0'.encode('ascii') * padding_len)
+
+        with catch_warnings(AstropyUserWarning) as w:
+            with fits.open(self.temp('temp.fits')) as hdul:
+                assert (hdul[0].data == a).all()
+        assert ('contains null bytes instead of spaces' in
+                str(w[0].message))
+        assert len(w) == 1
+        assert len(hdul) == 1
+        assert str(hdul[0].header) == str(hdu.header)
+
+    def test_update_with_truncated_header(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/148
+
+        Test that saving an update where the header is shorter than the
+        original header doesn't leave a stump from the old header in the file.
+        """
+
+        data = np.arange(100)
+        hdu = fits.PrimaryHDU(data=data)
+        idx = 1
+        while len(hdu.header) < 34:
+            hdu.header['TEST{}'.format(idx)] = idx
+            idx += 1
+        hdu.writeto(self.temp('temp.fits'), checksum=True)
+
+        with fits.open(self.temp('temp.fits'), mode='update') as hdul:
+            # Modify the header, forcing it to be rewritten
+            hdul[0].header['TEST1'] = 2
+
+        with fits.open(self.temp('temp.fits')) as hdul:
+            assert (hdul[0].data == data).all()
+
+    @pytest.mark.xfail(platform.system() == 'Windows',
+                       reason='https://github.com/astropy/astropy/issues/5797')
+    def test_update_resized_header(self):
+        """
+        Test saving updates to a file where the header is one block smaller
+        than before, and in the case where the heade ris one block larger than
+        before.
+        """
+
+        data = np.arange(100)
+        hdu = fits.PrimaryHDU(data=data)
+        idx = 1
+        while len(str(hdu.header)) <= 2880:
+            hdu.header['TEST{}'.format(idx)] = idx
+            idx += 1
+        orig_header = hdu.header.copy()
+        hdu.writeto(self.temp('temp.fits'))
+
+        with fits.open(self.temp('temp.fits'), mode='update') as hdul:
+            while len(str(hdul[0].header)) > 2880:
+                del hdul[0].header[-1]
+
+        with fits.open(self.temp('temp.fits')) as hdul:
+            assert hdul[0].header == orig_header[:-1]
+            assert (hdul[0].data == data).all()
+
+        with fits.open(self.temp('temp.fits'), mode='update') as hdul:
+            idx = 101
+            while len(str(hdul[0].header)) <= 2880 * 2:
+                hdul[0].header['TEST{}'.format(idx)] = idx
+                idx += 1
+            # Touch something in the data too so that it has to be rewritten
+            hdul[0].data[0] = 27
+
+        with fits.open(self.temp('temp.fits')) as hdul:
+            assert hdul[0].header[:-37] == orig_header[:-1]
+            assert hdul[0].data[0] == 27
+            assert (hdul[0].data[1:] == data[1:]).all()
+
+    def test_update_resized_header2(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/150
+
+        This is similar to test_update_resized_header, but specifically tests a
+        case of multiple consecutive flush() calls on the same HDUList object,
+        where each flush() requires a resize.
+        """
+
+        data1 = np.arange(100)
+        data2 = np.arange(100) + 100
+        phdu = fits.PrimaryHDU(data=data1)
+        hdu = fits.ImageHDU(data=data2)
+
+        phdu.writeto(self.temp('temp.fits'))
+
+        with fits.open(self.temp('temp.fits'), mode='append') as hdul:
+            hdul.append(hdu)
+
+        with fits.open(self.temp('temp.fits'), mode='update') as hdul:
+            idx = 1
+            while len(str(hdul[0].header)) <= 2880 * 2:
+                hdul[0].header['TEST{}'.format(idx)] = idx
+                idx += 1
+            hdul.flush()
+            hdul.append(hdu)
+
+        with fits.open(self.temp('temp.fits')) as hdul:
+            assert (hdul[0].data == data1).all()
+            assert hdul[1].header == hdu.header
+            assert (hdul[1].data == data2).all()
+            assert (hdul[2].data == data2).all()
+
+    @ignore_warnings()
+    def test_hdul_fromstring(self):
+        """
+        Test creating the HDUList structure in memory from a string containing
+        an entire FITS file.  This is similar to test_hdu_fromstring but for an
+        entire multi-extension FITS file at once.
+        """
+
+        # Tests HDUList.fromstring for all of Astropy's built in test files
+        def test_fromstring(filename):
+            with fits.open(filename) as hdul:
+                orig_info = hdul.info(output=False)
+                with open(filename, 'rb') as f:
+                    dat = f.read()
+
+                hdul2 = fits.HDUList.fromstring(dat)
+
+                assert orig_info == hdul2.info(output=False)
+                for idx in range(len(hdul)):
+                    assert hdul[idx].header == hdul2[idx].header
+                    if hdul[idx].data is None or hdul2[idx].data is None:
+                        assert hdul[idx].data == hdul2[idx].data
+                    elif (hdul[idx].data.dtype.fields and
+                          hdul2[idx].data.dtype.fields):
+                        # Compare tables
+                        for n in hdul[idx].data.names:
+                            c1 = hdul[idx].data[n]
+                            c2 = hdul2[idx].data[n]
+                            assert (c1 == c2).all()
+                    elif (any(dim == 0 for dim in hdul[idx].data.shape) or
+                          any(dim == 0 for dim in hdul2[idx].data.shape)):
+                        # For some reason some combinations of Python and Numpy
+                        # on Windows result in MemoryErrors when trying to work
+                        # on memmap arrays with more than one dimension but
+                        # some dimensions of size zero, so include a special
+                        # case for that
+                        return hdul[idx].data.shape == hdul2[idx].data.shape
+                    else:
+                        np.testing.assert_array_equal(hdul[idx].data,
+                                                      hdul2[idx].data)
+
+        for filename in glob.glob(os.path.join(self.data_dir, '*.fits')):
+            if sys.platform == 'win32' and filename == 'zerowidth.fits':
+                # Running this test on this file causes a crash in some
+                # versions of Numpy on Windows.  See ticket:
+                # https://aeon.stsci.edu/ssb/trac/pyfits/ticket/174
+                continue
+            elif filename.endswith('variable_length_table.fits'):
+                # Comparing variable length arrays is non-trivial and thus
+                # skipped at this point.
+                # TODO: That's probably possible, so one could make it work.
+                continue
+            test_fromstring(filename)
+
+        # Test that creating an HDUList from something silly raises a TypeError
+        pytest.raises(TypeError, fits.HDUList.fromstring, ['a', 'b', 'c'])
+
+    def test_save_backup(self):
+        """Test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/121
+
+        Save backup of file before flushing changes.
+        """
+
+        self.copy_file('scale.fits')
+
+        with ignore_warnings():
+            with fits.open(self.temp('scale.fits'), mode='update',
+                           save_backup=True) as hdul:
+                # Make some changes to the original file to force its header
+                # and data to be rewritten
+                hdul[0].header['TEST'] = 'TEST'
+                hdul[0].data[0] = 0
+
+        assert os.path.exists(self.temp('scale.fits.bak'))
+        with fits.open(self.data('scale.fits'),
+                       do_not_scale_image_data=True) as hdul1:
+            with fits.open(self.temp('scale.fits.bak'),
+                           do_not_scale_image_data=True) as hdul2:
+                assert hdul1[0].header == hdul2[0].header
+                assert (hdul1[0].data == hdul2[0].data).all()
+
+        with ignore_warnings():
+            with fits.open(self.temp('scale.fits'), mode='update',
+                           save_backup=True) as hdul:
+                # One more time to see if multiple backups are made
+                hdul[0].header['TEST2'] = 'TEST'
+                hdul[0].data[0] = 1
+
+        assert os.path.exists(self.temp('scale.fits.bak'))
+        assert os.path.exists(self.temp('scale.fits.bak.1'))
+
+    def test_replace_mmap_data(self):
+        """Regression test for
+        https://github.com/spacetelescope/PyFITS/issues/25
+
+        Replacing the mmap'd data of one file with mmap'd data from a
+        different file should work.
+        """
+
+        arr_a = np.arange(10)
+        arr_b = arr_a * 2
+
+        def test(mmap_a, mmap_b):
+            hdu_a = fits.PrimaryHDU(data=arr_a)
+            hdu_a.writeto(self.temp('test_a.fits'), overwrite=True)
+            hdu_b = fits.PrimaryHDU(data=arr_b)
+            hdu_b.writeto(self.temp('test_b.fits'), overwrite=True)
+
+            with fits.open(self.temp('test_a.fits'), mode='update',
+                           memmap=mmap_a) as hdul_a:
+                with fits.open(self.temp('test_b.fits'),
+                               memmap=mmap_b) as hdul_b:
+                    hdul_a[0].data = hdul_b[0].data
+
+            with fits.open(self.temp('test_a.fits')) as hdul_a:
+                assert np.all(hdul_a[0].data == arr_b)
+
+        with ignore_warnings():
+            test(True, True)
+
+            # Repeat the same test but this time don't mmap A
+            test(False, True)
+
+            # Finally, without mmaping B
+            test(True, False)
+
+    def test_replace_mmap_data_2(self):
+        """Regression test for
+        https://github.com/spacetelescope/PyFITS/issues/25
+
+        Replacing the mmap'd data of one file with mmap'd data from a
+        different file should work.  Like test_replace_mmap_data but with
+        table data instead of image data.
+        """
+
+        arr_a = np.arange(10)
+        arr_b = arr_a * 2
+
+        def test(mmap_a, mmap_b):
+            col_a = fits.Column(name='a', format='J', array=arr_a)
+            col_b = fits.Column(name='b', format='J', array=arr_b)
+            hdu_a = fits.BinTableHDU.from_columns([col_a])
+            hdu_a.writeto(self.temp('test_a.fits'), overwrite=True)
+            hdu_b = fits.BinTableHDU.from_columns([col_b])
+            hdu_b.writeto(self.temp('test_b.fits'), overwrite=True)
+
+            with fits.open(self.temp('test_a.fits'), mode='update',
+                           memmap=mmap_a) as hdul_a:
+                with fits.open(self.temp('test_b.fits'),
+                               memmap=mmap_b) as hdul_b:
+                    hdul_a[1].data = hdul_b[1].data
+
+            with fits.open(self.temp('test_a.fits')) as hdul_a:
+                assert 'b' in hdul_a[1].columns.names
+                assert 'a' not in hdul_a[1].columns.names
+                assert np.all(hdul_a[1].data['b'] == arr_b)
+
+        with ignore_warnings():
+            test(True, True)
+
+            # Repeat the same test but this time don't mmap A
+            test(False, True)
+
+            # Finally, without mmaping B
+            test(True, False)
+
+    def test_extname_in_hdulist(self):
+        """
+        Tests to make sure that the 'in' operator works.
+
+        Regression test for https://github.com/astropy/astropy/issues/3060
+        """
+        with fits.open(self.data('o4sp040b0_raw.fits')) as hdulist:
+            hdulist.append(fits.ImageHDU(name='a'))
+
+            assert 'a' in hdulist
+            assert 'A' in hdulist
+            assert ('a', 1) in hdulist
+            assert ('A', 1) in hdulist
+            assert 'b' not in hdulist
+            assert ('a', 2) not in hdulist
+            assert ('b', 1) not in hdulist
+            assert ('b', 2) not in hdulist
+            assert hdulist[0] in hdulist
+            assert fits.ImageHDU() not in hdulist
+
+    def test_overwrite_vs_clobber(self):
+        hdulist = fits.HDUList([fits.PrimaryHDU()])
+        hdulist.writeto(self.temp('test_overwrite.fits'))
+        hdulist.writeto(self.temp('test_overwrite.fits'), overwrite=True)
+        with catch_warnings(AstropyDeprecationWarning) as warning_lines:
+            hdulist.writeto(self.temp('test_overwrite.fits'), clobber=True)
+            assert warning_lines[0].category == AstropyDeprecationWarning
+            assert (str(warning_lines[0].message) == '"clobber" was '
+                    'deprecated in version 2.0 and will be removed in a '
+                    'future version. Use argument "overwrite" instead.')
+
+    def test_invalid_hdu_key_in_contains(self):
+        """
+        Make sure invalid keys in the 'in' operator return False.
+        Regression test for https://github.com/astropy/astropy/issues/5583
+        """
+        hdulist = fits.HDUList(fits.PrimaryHDU())
+        hdulist.append(fits.ImageHDU())
+        hdulist.append(fits.ImageHDU())
+
+        # A more or less random assortment of things which are not valid keys.
+        bad_keys = [None, 3.5, {}]
+
+        for key in bad_keys:
+            assert not (key in hdulist)
+
+    def test_iteration_of_lazy_loaded_hdulist(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/5585
+        """
+        hdulist = fits.HDUList(fits.PrimaryHDU())
+        hdulist.append(fits.ImageHDU(name='SCI'))
+        hdulist.append(fits.ImageHDU(name='SCI'))
+        hdulist.append(fits.ImageHDU(name='nada'))
+        hdulist.append(fits.ImageHDU(name='SCI'))
+
+        filename = self.temp('many_extension.fits')
+        hdulist.writeto(filename)
+        f = fits.open(filename)
+
+        # Check that all extensions are read if f is not sliced
+        all_exts = [ext for ext in f]
+        assert len(all_exts) == 5
+
+        # Reload the file to ensure we are still lazy loading
+        f.close()
+        f = fits.open(filename)
+
+        # Try a simple slice with no conditional on the ext. This is essentially
+        # the reported failure.
+        all_exts_but_zero = [ext for ext in f[1:]]
+        assert len(all_exts_but_zero) == 4
+
+        # Reload the file to ensure we are still lazy loading
+        f.close()
+        f = fits.open(filename)
+
+        # Check whether behavior is proper if the upper end of the slice is not
+        # omitted.
+        read_exts = [ext for ext in f[1:4] if ext.header['EXTNAME'] == 'SCI']
+        assert len(read_exts) == 2
+        f.close()
+
+    def test_proper_error_raised_on_non_fits_file_with_unicode(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/5594
+
+        The failure shows up when (in python 3+) you try to open a file
+        with unicode content that is not actually a FITS file. See:
+        https://github.com/astropy/astropy/issues/5594#issuecomment-266583218
+        """
+        import codecs
+        filename = self.temp('not-fits-with-unicode.fits')
+        with codecs.open(filename, mode='w', encoding='utf=8') as f:
+            f.write(u'Ce\xe7i ne marche pas')
+
+        # This should raise an OSError because there is no end card.
+        with pytest.raises(OSError):
+            with pytest.warns(AstropyUserWarning, match='non-ASCII characters '
+                              'are present in the FITS file header'):
+                fits.open(filename)
+
+    def test_no_resource_warning_raised_on_non_fits_file(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/6168
+
+        The ResourceWarning shows up when (in python 3+) you try to
+        open a non-FITS file when using a filename.
+        """
+
+        # To avoid creating the file multiple times the tests are
+        # all included in one test file. See the discussion to the
+        # PR at https://github.com/astropy/astropy/issues/6168
+        #
+        filename = self.temp('not-fits.fits')
+        with open(filename, mode='w') as f:
+            f.write('# header line\n')
+            f.write('0.1 0.2\n')
+
+        # Opening the file should raise an OSError however the file
+        # is opened (there are two distinct code paths, depending on
+        # whether ignore_missing_end is True or False).
+        #
+        # Explicit tests are added to make sure the file handle is not
+        # closed when passed in to fits.open. In this case the ResourceWarning
+        # was not raised, but a check is still included.
+        #
+        with catch_warnings(ResourceWarning) as ws:
+
+            # Make sure that files opened by the user are not closed
+            with open(filename, mode='rb') as f:
+                with pytest.raises(OSError):
+                    fits.open(f, ignore_missing_end=False)
+
+                assert not f.closed
+
+            with open(filename, mode='rb') as f:
+                with pytest.raises(OSError):
+                    fits.open(f, ignore_missing_end=True)
+
+                assert not f.closed
+
+            with pytest.raises(OSError):
+                fits.open(filename, ignore_missing_end=False)
+
+            with pytest.raises(OSError):
+                fits.open(filename, ignore_missing_end=True)
+
+        assert len(ws) == 0
+
+    def test_pop_with_lazy_load(self):
+        filename = self.data('checksum.fits')
+
+        with fits.open(filename) as hdul:
+            # Try popping the hdulist before doing anything else. This makes sure
+            # that https://github.com/astropy/astropy/issues/7185 is fixed.
+            hdu = hdul.pop()
+            assert len(hdul) == 1
+
+        # Read the file again and try popping from the beginning
+        with fits.open(filename) as hdul2:
+            hdu2 = hdul2.pop(0)
+            assert len(hdul2) == 1
+
+        # Just a sanity check
+        with fits.open(filename) as hdul3:
+            assert len(hdul3) == 2
+            assert hdul3[0].header == hdu2.header
+            assert hdul3[1].header == hdu.header
+
+    def test_pop_extname(self):
+        with fits.open(self.data('o4sp040b0_raw.fits')) as hdul:
+            assert len(hdul) == 7
+            hdu1 = hdul[1]
+            hdu4 = hdul[4]
+            hdu_popped = hdul.pop(('SCI', 2))
+            assert len(hdul) == 6
+            assert hdu_popped is hdu4
+            hdu_popped = hdul.pop('SCI')
+            assert len(hdul) == 5
+            assert hdu_popped is hdu1
+
+    def test_write_hdulist_to_stream(self):
+        """
+        Unit test for https://github.com/astropy/astropy/issues/7435
+        Ensure that an HDUList can be written to a stream in Python 2
+        """
+        data = np.array([[1,2,3],[4,5,6]])
+        hdu = fits.PrimaryHDU(data)
+        hdulist = fits.HDUList([hdu])
+
+        with open(self.temp('test.fits'), 'wb') as fout:
+            with subprocess.Popen(["cat"], stdin=subprocess.PIPE,
+                                  stdout=fout) as p:
+                hdulist.writeto(p.stdin)

testbed/astropy__astropy/astropy/io/fits/tests/test_image.py

@@ -0,0 +1,1968 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+
+import math
+import os
+import platform
+import re
+import time
+import warnings
+
+import pytest
+import numpy as np
+from numpy.testing import assert_equal
+
+from astropy.io import fits
+from astropy.tests.helper import catch_warnings, ignore_warnings
+from astropy.io.fits.hdu.compressed import SUBTRACTIVE_DITHER_1, DITHER_SEED_CHECKSUM
+from .test_table import comparerecords
+
+from . import FitsTestCase
+
+try:
+    import scipy  # noqa
+except ImportError:
+    HAS_SCIPY = False
+else:
+    HAS_SCIPY = True
+
+
+class TestImageFunctions(FitsTestCase):
+    def test_constructor_name_arg(self):
+        """Like the test of the same name in test_table.py"""
+
+        hdu = fits.ImageHDU()
+        assert hdu.name == ''
+        assert 'EXTNAME' not in hdu.header
+        hdu.name = 'FOO'
+        assert hdu.name == 'FOO'
+        assert hdu.header['EXTNAME'] == 'FOO'
+
+        # Passing name to constructor
+        hdu = fits.ImageHDU(name='FOO')
+        assert hdu.name == 'FOO'
+        assert hdu.header['EXTNAME'] == 'FOO'
+
+        # And overriding a header with a different extname
+        hdr = fits.Header()
+        hdr['EXTNAME'] = 'EVENTS'
+        hdu = fits.ImageHDU(header=hdr, name='FOO')
+        assert hdu.name == 'FOO'
+        assert hdu.header['EXTNAME'] == 'FOO'
+
+    def test_constructor_ver_arg(self):
+        def assert_ver_is(hdu, reference_ver):
+            assert hdu.ver == reference_ver
+            assert hdu.header['EXTVER'] == reference_ver
+
+        hdu = fits.ImageHDU()
+        assert hdu.ver == 1  # defaults to 1
+        assert 'EXTVER' not in hdu.header
+
+        hdu.ver = 1
+        assert_ver_is(hdu, 1)
+
+        # Passing name to constructor
+        hdu = fits.ImageHDU(ver=2)
+        assert_ver_is(hdu, 2)
+
+        # And overriding a header with a different extver
+        hdr = fits.Header()
+        hdr['EXTVER'] = 3
+        hdu = fits.ImageHDU(header=hdr, ver=4)
+        assert_ver_is(hdu, 4)
+
+        # The header card is not overridden if ver is None or not passed in
+        hdr = fits.Header()
+        hdr['EXTVER'] = 5
+        hdu = fits.ImageHDU(header=hdr, ver=None)
+        assert_ver_is(hdu, 5)
+        hdu = fits.ImageHDU(header=hdr)
+        assert_ver_is(hdu, 5)
+
+    def test_constructor_copies_header(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/153
+
+        Ensure that a header from one HDU is copied when used to initialize new
+        HDU.
+        """
+
+        ifd = fits.HDUList(fits.PrimaryHDU())
+        phdr = ifd[0].header
+        phdr['FILENAME'] = 'labq01i3q_rawtag.fits'
+
+        primary_hdu = fits.PrimaryHDU(header=phdr)
+        ofd = fits.HDUList(primary_hdu)
+        ofd[0].header['FILENAME'] = 'labq01i3q_flt.fits'
+
+        # Original header should be unchanged
+        assert phdr['FILENAME'] == 'labq01i3q_rawtag.fits'
+
+    def test_open(self):
+        # The function "open" reads a FITS file into an HDUList object.  There
+        # are three modes to open: "readonly" (the default), "append", and
+        # "update".
+
+        # Open a file read-only (the default mode), the content of the FITS
+        # file are read into memory.
+        r = fits.open(self.data('test0.fits'))  # readonly
+
+        # data parts are latent instantiation, so if we close the HDUList
+        # without touching data, data can not be accessed.
+        r.close()
+
+        with pytest.raises(IndexError) as exc_info:
+            r[1].data[:2, :2]
+
+        # Check that the exception message is the enhanced version, not the
+        # default message from list.__getitem__
+        assert str(exc_info.value) == ('HDU not found, possibly because the index '
+                                       'is out of range, or because the file was '
+                                       'closed before all HDUs were read')
+
+    def test_open_2(self):
+        r = fits.open(self.data('test0.fits'))
+
+        info = ([(0, 'PRIMARY', 1, 'PrimaryHDU', 138, (), '', '')] +
+                [(x, 'SCI', x, 'ImageHDU', 61, (40, 40), 'int16', '')
+                 for x in range(1, 5)])
+
+        try:
+            assert r.info(output=False) == info
+        finally:
+            r.close()
+
+    def test_open_3(self):
+        # Test that HDUs cannot be accessed after the file was closed
+        r = fits.open(self.data('test0.fits'))
+        r.close()
+        with pytest.raises(IndexError) as exc_info:
+            r[1]
+
+        # Check that the exception message is the enhanced version, not the
+        # default message from list.__getitem__
+        assert str(exc_info.value) == ('HDU not found, possibly because the index '
+                                       'is out of range, or because the file was '
+                                       'closed before all HDUs were read')
+
+        # Test that HDUs can be accessed with lazy_load_hdus=False
+        r = fits.open(self.data('test0.fits'), lazy_load_hdus=False)
+        r.close()
+        assert isinstance(r[1], fits.ImageHDU)
+        assert len(r) == 5
+
+        with pytest.raises(IndexError) as exc_info:
+            r[6]
+        assert str(exc_info.value) == 'list index out of range'
+
+        # And the same with the global config item
+        assert fits.conf.lazy_load_hdus  # True by default
+        fits.conf.lazy_load_hdus = False
+        try:
+            r = fits.open(self.data('test0.fits'))
+            r.close()
+            assert isinstance(r[1], fits.ImageHDU)
+            assert len(r) == 5
+        finally:
+            fits.conf.lazy_load_hdus = True
+
+    def test_fortran_array(self):
+        # Test that files are being correctly written+read for "C" and "F" order arrays
+        a = np.arange(21).reshape(3,7)
+        b = np.asfortranarray(a)
+
+        afits = self.temp('a_str.fits')
+        bfits = self.temp('b_str.fits')
+        # writting to str specified files
+        fits.PrimaryHDU(data=a).writeto(afits)
+        fits.PrimaryHDU(data=b).writeto(bfits)
+        np.testing.assert_array_equal(fits.getdata(afits), a)
+        np.testing.assert_array_equal(fits.getdata(bfits), a)
+
+        # writting to fileobjs
+        aafits = self.temp('a_fileobj.fits')
+        bbfits = self.temp('b_fileobj.fits')
+        with open(aafits, mode='wb') as fd:
+            fits.PrimaryHDU(data=a).writeto(fd)
+        with open(bbfits, mode='wb') as fd:
+            fits.PrimaryHDU(data=b).writeto(fd)
+        np.testing.assert_array_equal(fits.getdata(aafits), a)
+        np.testing.assert_array_equal(fits.getdata(bbfits), a)
+
+    def test_fortran_array_non_contiguous(self):
+        # Test that files are being correctly written+read for 'C' and 'F' order arrays
+        a = np.arange(105).reshape(3,5,7)
+        b = np.asfortranarray(a)
+
+        # writting to str specified files
+        afits = self.temp('a_str_slice.fits')
+        bfits = self.temp('b_str_slice.fits')
+        fits.PrimaryHDU(data=a[::2, ::2]).writeto(afits)
+        fits.PrimaryHDU(data=b[::2, ::2]).writeto(bfits)
+        np.testing.assert_array_equal(fits.getdata(afits), a[::2, ::2])
+        np.testing.assert_array_equal(fits.getdata(bfits), a[::2, ::2])
+
+        # writting to fileobjs
+        aafits = self.temp('a_fileobj_slice.fits')
+        bbfits = self.temp('b_fileobj_slice.fits')
+        with open(aafits, mode='wb') as fd:
+            fits.PrimaryHDU(data=a[::2, ::2]).writeto(fd)
+        with open(bbfits, mode='wb') as fd:
+            fits.PrimaryHDU(data=b[::2, ::2]).writeto(fd)
+        np.testing.assert_array_equal(fits.getdata(aafits), a[::2, ::2])
+        np.testing.assert_array_equal(fits.getdata(bbfits), a[::2, ::2])
+
+
+    def test_primary_with_extname(self):
+        """Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/151
+
+        Tests that the EXTNAME keyword works with Primary HDUs as well, and
+        interacts properly with the .name attribute.  For convenience
+        hdulist['PRIMARY'] will still refer to the first HDU even if it has an
+        EXTNAME not equal to 'PRIMARY'.
+        """
+
+        prihdr = fits.Header([('EXTNAME', 'XPRIMARY'), ('EXTVER', 1)])
+        hdul = fits.HDUList([fits.PrimaryHDU(header=prihdr)])
+        assert 'EXTNAME' in hdul[0].header
+        assert hdul[0].name == 'XPRIMARY'
+        assert hdul[0].name == hdul[0].header['EXTNAME']
+
+        info = [(0, 'XPRIMARY', 1, 'PrimaryHDU', 5, (), '', '')]
+        assert hdul.info(output=False) == info
+
+        assert hdul['PRIMARY'] is hdul['XPRIMARY']
+        assert hdul['PRIMARY'] is hdul[('XPRIMARY', 1)]
+
+        hdul[0].name = 'XPRIMARY2'
+        assert hdul[0].header['EXTNAME'] == 'XPRIMARY2'
+
+        hdul.writeto(self.temp('test.fits'))
+        with fits.open(self.temp('test.fits')) as hdul:
+            assert hdul[0].name == 'XPRIMARY2'
+
+    @pytest.mark.xfail(platform.system() == 'Windows',
+                       reason='https://github.com/astropy/astropy/issues/5797')
+    def test_io_manipulation(self):
+        # Get a keyword value.  An extension can be referred by name or by
+        # number.  Both extension and keyword names are case insensitive.
+        with fits.open(self.data('test0.fits')) as r:
+            assert r['primary'].header['naxis'] == 0
+            assert r[0].header['naxis'] == 0
+
+            # If there are more than one extension with the same EXTNAME value,
+            # the EXTVER can be used (as the second argument) to distinguish
+            # the extension.
+            assert r['sci', 1].header['detector'] == 1
+
+            # append (using "update()") a new card
+            r[0].header['xxx'] = 1.234e56
+
+            assert ('\n'.join(str(x) for x in r[0].header.cards[-3:]) ==
+                    "EXPFLAG = 'NORMAL            ' / Exposure interruption indicator                \n"
+                    "FILENAME= 'vtest3.fits'        / File name                                      \n"
+                    "XXX     =            1.234E+56                                                  ")
+
+            # rename a keyword
+            r[0].header.rename_keyword('filename', 'fname')
+            pytest.raises(ValueError, r[0].header.rename_keyword, 'fname',
+                          'history')
+
+            pytest.raises(ValueError, r[0].header.rename_keyword, 'fname',
+                          'simple')
+            r[0].header.rename_keyword('fname', 'filename')
+
+            # get a subsection of data
+            assert np.array_equal(r[2].data[:3, :3],
+                                  np.array([[349, 349, 348],
+                                            [349, 349, 347],
+                                            [347, 350, 349]], dtype=np.int16))
+
+            # We can create a new FITS file by opening a new file with "append"
+            # mode.
+            with fits.open(self.temp('test_new.fits'), mode='append') as n:
+                # Append the primary header and the 2nd extension to the new
+                # file.
+                n.append(r[0])
+                n.append(r[2])
+
+                # The flush method will write the current HDUList object back
+                # to the newly created file on disk.  The HDUList is still open
+                # and can be further operated.
+                n.flush()
+                assert n[1].data[1, 1] == 349
+
+                # modify a data point
+                n[1].data[1, 1] = 99
+
+                # When the file is closed, the most recent additions of
+                # extension(s) since last flush() will be appended, but any HDU
+                # already existed at the last flush will not be modified
+            del n
+
+            # If an existing file is opened with "append" mode, like the
+            # readonly mode, the HDU's will be read into the HDUList which can
+            # be modified in memory but can not be written back to the original
+            # file.  A file opened with append mode can only add new HDU's.
+            os.rename(self.temp('test_new.fits'),
+                      self.temp('test_append.fits'))
+
+            with fits.open(self.temp('test_append.fits'), mode='append') as a:
+
+                # The above change did not take effect since this was made
+                # after the flush().
+                assert a[1].data[1, 1] == 349
+                a.append(r[1])
+            del a
+
+            # When changes are made to an HDUList which was opened with
+            # "update" mode, they will be written back to the original file
+            # when a flush/close is called.
+            os.rename(self.temp('test_append.fits'),
+                      self.temp('test_update.fits'))
+
+            with fits.open(self.temp('test_update.fits'), mode='update') as u:
+
+                # When the changes do not alter the size structures of the
+                # original (or since last flush) HDUList, the changes are
+                # written back "in place".
+                assert u[0].header['rootname'] == 'U2EQ0201T'
+                u[0].header['rootname'] = 'abc'
+                assert u[1].data[1, 1] == 349
+                u[1].data[1, 1] = 99
+                u.flush()
+
+                # If the changes affect the size structure, e.g. adding or
+                # deleting HDU(s), header was expanded or reduced beyond
+                # existing number of blocks (2880 bytes in each block), or
+                # change the data size, the HDUList is written to a temporary
+                # file, the original file is deleted, and the temporary file is
+                # renamed to the original file name and reopened in the update
+                # mode.  To a user, these two kinds of updating writeback seem
+                # to be the same, unless the optional argument in flush or
+                # close is set to 1.
+                del u[2]
+                u.flush()
+
+                # the write method in HDUList class writes the current HDUList,
+                # with all changes made up to now, to a new file.  This method
+                # works the same disregard the mode the HDUList was opened
+                # with.
+                u.append(r[3])
+                u.writeto(self.temp('test_new.fits'))
+            del u
+
+        # Another useful new HDUList method is readall.  It will "touch" the
+        # data parts in all HDUs, so even if the HDUList is closed, we can
+        # still operate on the data.
+        with fits.open(self.data('test0.fits')) as r:
+            r.readall()
+            assert r[1].data[1, 1] == 315
+
+        # create an HDU with data only
+        data = np.ones((3, 5), dtype=np.float32)
+        hdu = fits.ImageHDU(data=data, name='SCI')
+        assert np.array_equal(hdu.data,
+                              np.array([[1., 1., 1., 1., 1.],
+                                        [1., 1., 1., 1., 1.],
+                                        [1., 1., 1., 1., 1.]],
+                                       dtype=np.float32))
+
+        # create an HDU with header and data
+        # notice that the header has the right NAXIS's since it is constructed
+        # with ImageHDU
+        hdu2 = fits.ImageHDU(header=r[1].header, data=np.array([1, 2],
+                             dtype='int32'))
+
+        assert ('\n'.join(str(x) for x in hdu2.header.cards[1:5]) ==
+            "BITPIX  =                   32 / array data type                                \n"
+            "NAXIS   =                    1 / number of array dimensions                     \n"
+            "NAXIS1  =                    2                                                  \n"
+            "PCOUNT  =                    0 / number of parameters                           ")
+
+    def test_memory_mapping(self):
+        # memory mapping
+        f1 = fits.open(self.data('test0.fits'), memmap=1)
+        f1.close()
+
+    def test_verification_on_output(self):
+        # verification on output
+        # make a defect HDUList first
+        x = fits.ImageHDU()
+        hdu = fits.HDUList(x)  # HDUList can take a list or one single HDU
+        with catch_warnings() as w:
+            hdu.verify()
+        text = "HDUList's 0th element is not a primary HDU."
+        assert len(w) == 3
+        assert text in str(w[1].message)
+
+        with catch_warnings() as w:
+            hdu.writeto(self.temp('test_new2.fits'), 'fix')
+        text = ("HDUList's 0th element is not a primary HDU.  "
+                "Fixed by inserting one as 0th HDU.")
+        assert len(w) == 3
+        assert text in str(w[1].message)
+
+    def test_section(self):
+        # section testing
+        fs = fits.open(self.data('arange.fits'))
+        assert np.array_equal(fs[0].section[3, 2, 5], 357)
+        assert np.array_equal(
+            fs[0].section[3, 2, :],
+            np.array([352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362]))
+        assert np.array_equal(fs[0].section[3, 2, 4:],
+                              np.array([356, 357, 358, 359, 360, 361, 362]))
+        assert np.array_equal(fs[0].section[3, 2, :8],
+                              np.array([352, 353, 354, 355, 356, 357, 358, 359]))
+        assert np.array_equal(fs[0].section[3, 2, -8:8],
+                              np.array([355, 356, 357, 358, 359]))
+        assert np.array_equal(
+            fs[0].section[3, 2:5, :],
+            np.array([[352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362],
+                      [363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373],
+                      [374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384]]))
+
+        assert np.array_equal(fs[0].section[3, :, :][:3, :3],
+                              np.array([[330, 331, 332],
+                                        [341, 342, 343],
+                                        [352, 353, 354]]))
+
+        dat = fs[0].data
+        assert np.array_equal(fs[0].section[3, 2:5, :8], dat[3, 2:5, :8])
+        assert np.array_equal(fs[0].section[3, 2:5, 3], dat[3, 2:5, 3])
+
+        assert np.array_equal(fs[0].section[3:6, :, :][:3, :3, :3],
+                              np.array([[[330, 331, 332],
+                                         [341, 342, 343],
+                                         [352, 353, 354]],
+                                        [[440, 441, 442],
+                                         [451, 452, 453],
+                                         [462, 463, 464]],
+                                        [[550, 551, 552],
+                                         [561, 562, 563],
+                                         [572, 573, 574]]]))
+
+        assert np.array_equal(fs[0].section[:, :, :][:3, :2, :2],
+                              np.array([[[0, 1],
+                                         [11, 12]],
+                                        [[110, 111],
+                                         [121, 122]],
+                                        [[220, 221],
+                                         [231, 232]]]))
+
+        assert np.array_equal(fs[0].section[:, 2, :], dat[:, 2, :])
+        assert np.array_equal(fs[0].section[:, 2:5, :], dat[:, 2:5, :])
+        assert np.array_equal(fs[0].section[3:6, 3, :], dat[3:6, 3, :])
+        assert np.array_equal(fs[0].section[3:6, 3:7, :], dat[3:6, 3:7, :])
+
+        assert np.array_equal(fs[0].section[:, ::2], dat[:, ::2])
+        assert np.array_equal(fs[0].section[:, [1, 2, 4], 3],
+                              dat[:, [1, 2, 4], 3])
+        bool_index = np.array([True, False, True, True, False,
+                               False, True, True, False, True])
+        assert np.array_equal(fs[0].section[:, bool_index, :],
+                              dat[:, bool_index, :])
+
+        assert np.array_equal(
+            fs[0].section[3:6, 3, :, ...], dat[3:6, 3, :, ...])
+        assert np.array_equal(fs[0].section[..., ::2], dat[..., ::2])
+        assert np.array_equal(fs[0].section[..., [1, 2, 4], 3],
+                              dat[..., [1, 2, 4], 3])
+        fs.close()
+
+    def test_section_data_single(self):
+        a = np.array([1])
+        hdu = fits.PrimaryHDU(a)
+        hdu.writeto(self.temp('test_new.fits'))
+
+        hdul = fits.open(self.temp('test_new.fits'))
+        sec = hdul[0].section
+        dat = hdul[0].data
+        assert np.array_equal(sec[0], dat[0])
+        assert np.array_equal(sec[...], dat[...])
+        assert np.array_equal(sec[..., 0], dat[..., 0])
+        assert np.array_equal(sec[0, ...], dat[0, ...])
+        hdul.close()
+
+    def test_section_data_square(self):
+        a = np.arange(4).reshape(2, 2)
+        hdu = fits.PrimaryHDU(a)
+        hdu.writeto(self.temp('test_new.fits'))
+
+        hdul = fits.open(self.temp('test_new.fits'))
+        d = hdul[0]
+        dat = hdul[0].data
+        assert (d.section[:, :] == dat[:, :]).all()
+        assert (d.section[0, :] == dat[0, :]).all()
+        assert (d.section[1, :] == dat[1, :]).all()
+        assert (d.section[:, 0] == dat[:, 0]).all()
+        assert (d.section[:, 1] == dat[:, 1]).all()
+        assert (d.section[0, 0] == dat[0, 0]).all()
+        assert (d.section[0, 1] == dat[0, 1]).all()
+        assert (d.section[1, 0] == dat[1, 0]).all()
+        assert (d.section[1, 1] == dat[1, 1]).all()
+        assert (d.section[0:1, 0:1] == dat[0:1, 0:1]).all()
+        assert (d.section[0:2, 0:1] == dat[0:2, 0:1]).all()
+        assert (d.section[0:1, 0:2] == dat[0:1, 0:2]).all()
+        assert (d.section[0:2, 0:2] == dat[0:2, 0:2]).all()
+        hdul.close()
+
+    def test_section_data_cube(self):
+        a = np.arange(18).reshape(2, 3, 3)
+        hdu = fits.PrimaryHDU(a)
+        hdu.writeto(self.temp('test_new.fits'))
+
+        hdul = fits.open(self.temp('test_new.fits'))
+        d = hdul[0]
+        dat = hdul[0].data
+
+        # TODO: Generate these perumtions instead of having them all written
+        # out, yeesh!
+        assert (d.section[:, :, :] == dat[:, :, :]).all()
+        assert (d.section[:, :] == dat[:, :]).all()
+        assert (d.section[:] == dat[:]).all()
+        assert (d.section[0, :, :] == dat[0, :, :]).all()
+        assert (d.section[1, :, :] == dat[1, :, :]).all()
+        assert (d.section[0, 0, :] == dat[0, 0, :]).all()
+        assert (d.section[0, 1, :] == dat[0, 1, :]).all()
+        assert (d.section[0, 2, :] == dat[0, 2, :]).all()
+        assert (d.section[1, 0, :] == dat[1, 0, :]).all()
+        assert (d.section[1, 1, :] == dat[1, 1, :]).all()
+        assert (d.section[1, 2, :] == dat[1, 2, :]).all()
+        assert (d.section[0, 0, 0] == dat[0, 0, 0]).all()
+        assert (d.section[0, 0, 1] == dat[0, 0, 1]).all()
+        assert (d.section[0, 0, 2] == dat[0, 0, 2]).all()
+        assert (d.section[0, 1, 0] == dat[0, 1, 0]).all()
+        assert (d.section[0, 1, 1] == dat[0, 1, 1]).all()
+        assert (d.section[0, 1, 2] == dat[0, 1, 2]).all()
+        assert (d.section[0, 2, 0] == dat[0, 2, 0]).all()
+        assert (d.section[0, 2, 1] == dat[0, 2, 1]).all()
+        assert (d.section[0, 2, 2] == dat[0, 2, 2]).all()
+        assert (d.section[1, 0, 0] == dat[1, 0, 0]).all()
+        assert (d.section[1, 0, 1] == dat[1, 0, 1]).all()
+        assert (d.section[1, 0, 2] == dat[1, 0, 2]).all()
+        assert (d.section[1, 1, 0] == dat[1, 1, 0]).all()
+        assert (d.section[1, 1, 1] == dat[1, 1, 1]).all()
+        assert (d.section[1, 1, 2] == dat[1, 1, 2]).all()
+        assert (d.section[1, 2, 0] == dat[1, 2, 0]).all()
+        assert (d.section[1, 2, 1] == dat[1, 2, 1]).all()
+        assert (d.section[1, 2, 2] == dat[1, 2, 2]).all()
+        assert (d.section[:, 0, 0] == dat[:, 0, 0]).all()
+        assert (d.section[:, 0, 1] == dat[:, 0, 1]).all()
+        assert (d.section[:, 0, 2] == dat[:, 0, 2]).all()
+        assert (d.section[:, 1, 0] == dat[:, 1, 0]).all()
+        assert (d.section[:, 1, 1] == dat[:, 1, 1]).all()
+        assert (d.section[:, 1, 2] == dat[:, 1, 2]).all()
+        assert (d.section[:, 2, 0] == dat[:, 2, 0]).all()
+        assert (d.section[:, 2, 1] == dat[:, 2, 1]).all()
+        assert (d.section[:, 2, 2] == dat[:, 2, 2]).all()
+        assert (d.section[0, :, 0] == dat[0, :, 0]).all()
+        assert (d.section[0, :, 1] == dat[0, :, 1]).all()
+        assert (d.section[0, :, 2] == dat[0, :, 2]).all()
+        assert (d.section[1, :, 0] == dat[1, :, 0]).all()
+        assert (d.section[1, :, 1] == dat[1, :, 1]).all()
+        assert (d.section[1, :, 2] == dat[1, :, 2]).all()
+        assert (d.section[:, :, 0] == dat[:, :, 0]).all()
+        assert (d.section[:, :, 1] == dat[:, :, 1]).all()
+        assert (d.section[:, :, 2] == dat[:, :, 2]).all()
+        assert (d.section[:, 0, :] == dat[:, 0, :]).all()
+        assert (d.section[:, 1, :] == dat[:, 1, :]).all()
+        assert (d.section[:, 2, :] == dat[:, 2, :]).all()
+
+        assert (d.section[:, :, 0:1] == dat[:, :, 0:1]).all()
+        assert (d.section[:, :, 0:2] == dat[:, :, 0:2]).all()
+        assert (d.section[:, :, 0:3] == dat[:, :, 0:3]).all()
+        assert (d.section[:, :, 1:2] == dat[:, :, 1:2]).all()
+        assert (d.section[:, :, 1:3] == dat[:, :, 1:3]).all()
+        assert (d.section[:, :, 2:3] == dat[:, :, 2:3]).all()
+        assert (d.section[0:1, 0:1, 0:1] == dat[0:1, 0:1, 0:1]).all()
+        assert (d.section[0:1, 0:1, 0:2] == dat[0:1, 0:1, 0:2]).all()
+        assert (d.section[0:1, 0:1, 0:3] == dat[0:1, 0:1, 0:3]).all()
+        assert (d.section[0:1, 0:1, 1:2] == dat[0:1, 0:1, 1:2]).all()
+        assert (d.section[0:1, 0:1, 1:3] == dat[0:1, 0:1, 1:3]).all()
+        assert (d.section[0:1, 0:1, 2:3] == dat[0:1, 0:1, 2:3]).all()
+        assert (d.section[0:1, 0:2, 0:1] == dat[0:1, 0:2, 0:1]).all()
+        assert (d.section[0:1, 0:2, 0:2] == dat[0:1, 0:2, 0:2]).all()
+        assert (d.section[0:1, 0:2, 0:3] == dat[0:1, 0:2, 0:3]).all()
+        assert (d.section[0:1, 0:2, 1:2] == dat[0:1, 0:2, 1:2]).all()
+        assert (d.section[0:1, 0:2, 1:3] == dat[0:1, 0:2, 1:3]).all()
+        assert (d.section[0:1, 0:2, 2:3] == dat[0:1, 0:2, 2:3]).all()
+        assert (d.section[0:1, 0:3, 0:1] == dat[0:1, 0:3, 0:1]).all()
+        assert (d.section[0:1, 0:3, 0:2] == dat[0:1, 0:3, 0:2]).all()
+        assert (d.section[0:1, 0:3, 0:3] == dat[0:1, 0:3, 0:3]).all()
+        assert (d.section[0:1, 0:3, 1:2] == dat[0:1, 0:3, 1:2]).all()
+        assert (d.section[0:1, 0:3, 1:3] == dat[0:1, 0:3, 1:3]).all()
+        assert (d.section[0:1, 0:3, 2:3] == dat[0:1, 0:3, 2:3]).all()
+        assert (d.section[0:1, 1:2, 0:1] == dat[0:1, 1:2, 0:1]).all()
+        assert (d.section[0:1, 1:2, 0:2] == dat[0:1, 1:2, 0:2]).all()
+        assert (d.section[0:1, 1:2, 0:3] == dat[0:1, 1:2, 0:3]).all()
+        assert (d.section[0:1, 1:2, 1:2] == dat[0:1, 1:2, 1:2]).all()
+        assert (d.section[0:1, 1:2, 1:3] == dat[0:1, 1:2, 1:3]).all()
+        assert (d.section[0:1, 1:2, 2:3] == dat[0:1, 1:2, 2:3]).all()
+        assert (d.section[0:1, 1:3, 0:1] == dat[0:1, 1:3, 0:1]).all()
+        assert (d.section[0:1, 1:3, 0:2] == dat[0:1, 1:3, 0:2]).all()
+        assert (d.section[0:1, 1:3, 0:3] == dat[0:1, 1:3, 0:3]).all()
+        assert (d.section[0:1, 1:3, 1:2] == dat[0:1, 1:3, 1:2]).all()
+        assert (d.section[0:1, 1:3, 1:3] == dat[0:1, 1:3, 1:3]).all()
+        assert (d.section[0:1, 1:3, 2:3] == dat[0:1, 1:3, 2:3]).all()
+        assert (d.section[1:2, 0:1, 0:1] == dat[1:2, 0:1, 0:1]).all()
+        assert (d.section[1:2, 0:1, 0:2] == dat[1:2, 0:1, 0:2]).all()
+        assert (d.section[1:2, 0:1, 0:3] == dat[1:2, 0:1, 0:3]).all()
+        assert (d.section[1:2, 0:1, 1:2] == dat[1:2, 0:1, 1:2]).all()
+        assert (d.section[1:2, 0:1, 1:3] == dat[1:2, 0:1, 1:3]).all()
+        assert (d.section[1:2, 0:1, 2:3] == dat[1:2, 0:1, 2:3]).all()
+        assert (d.section[1:2, 0:2, 0:1] == dat[1:2, 0:2, 0:1]).all()
+        assert (d.section[1:2, 0:2, 0:2] == dat[1:2, 0:2, 0:2]).all()
+        assert (d.section[1:2, 0:2, 0:3] == dat[1:2, 0:2, 0:3]).all()
+        assert (d.section[1:2, 0:2, 1:2] == dat[1:2, 0:2, 1:2]).all()
+        assert (d.section[1:2, 0:2, 1:3] == dat[1:2, 0:2, 1:3]).all()
+        assert (d.section[1:2, 0:2, 2:3] == dat[1:2, 0:2, 2:3]).all()
+        assert (d.section[1:2, 0:3, 0:1] == dat[1:2, 0:3, 0:1]).all()
+        assert (d.section[1:2, 0:3, 0:2] == dat[1:2, 0:3, 0:2]).all()
+        assert (d.section[1:2, 0:3, 0:3] == dat[1:2, 0:3, 0:3]).all()
+        assert (d.section[1:2, 0:3, 1:2] == dat[1:2, 0:3, 1:2]).all()
+        assert (d.section[1:2, 0:3, 1:3] == dat[1:2, 0:3, 1:3]).all()
+        assert (d.section[1:2, 0:3, 2:3] == dat[1:2, 0:3, 2:3]).all()
+        assert (d.section[1:2, 1:2, 0:1] == dat[1:2, 1:2, 0:1]).all()
+        assert (d.section[1:2, 1:2, 0:2] == dat[1:2, 1:2, 0:2]).all()
+        assert (d.section[1:2, 1:2, 0:3] == dat[1:2, 1:2, 0:3]).all()
+        assert (d.section[1:2, 1:2, 1:2] == dat[1:2, 1:2, 1:2]).all()
+        assert (d.section[1:2, 1:2, 1:3] == dat[1:2, 1:2, 1:3]).all()
+        assert (d.section[1:2, 1:2, 2:3] == dat[1:2, 1:2, 2:3]).all()
+        assert (d.section[1:2, 1:3, 0:1] == dat[1:2, 1:3, 0:1]).all()
+        assert (d.section[1:2, 1:3, 0:2] == dat[1:2, 1:3, 0:2]).all()
+        assert (d.section[1:2, 1:3, 0:3] == dat[1:2, 1:3, 0:3]).all()
+        assert (d.section[1:2, 1:3, 1:2] == dat[1:2, 1:3, 1:2]).all()
+        assert (d.section[1:2, 1:3, 1:3] == dat[1:2, 1:3, 1:3]).all()
+        assert (d.section[1:2, 1:3, 2:3] == dat[1:2, 1:3, 2:3]).all()
+        hdul.close()
+
+    def test_section_data_four(self):
+        a = np.arange(256).reshape(4, 4, 4, 4)
+        hdu = fits.PrimaryHDU(a)
+        hdu.writeto(self.temp('test_new.fits'))
+
+        hdul = fits.open(self.temp('test_new.fits'))
+        d = hdul[0]
+        dat = hdul[0].data
+        assert (d.section[:, :, :, :] == dat[:, :, :, :]).all()
+        assert (d.section[:, :, :] == dat[:, :, :]).all()
+        assert (d.section[:, :] == dat[:, :]).all()
+        assert (d.section[:] == dat[:]).all()
+        assert (d.section[0, :, :, :] == dat[0, :, :, :]).all()
+        assert (d.section[0, :, 0, :] == dat[0, :, 0, :]).all()
+        assert (d.section[:, :, 0, :] == dat[:, :, 0, :]).all()
+        assert (d.section[:, 1, 0, :] == dat[:, 1, 0, :]).all()
+        assert (d.section[:, :, :, 1] == dat[:, :, :, 1]).all()
+        hdul.close()
+
+    def test_section_data_scaled(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/143
+
+        This is like test_section_data_square but uses a file containing scaled
+        image data, to test that sections can work correctly with scaled data.
+        """
+
+        hdul = fits.open(self.data('scale.fits'))
+        d = hdul[0]
+        dat = hdul[0].data
+        assert (d.section[:, :] == dat[:, :]).all()
+        assert (d.section[0, :] == dat[0, :]).all()
+        assert (d.section[1, :] == dat[1, :]).all()
+        assert (d.section[:, 0] == dat[:, 0]).all()
+        assert (d.section[:, 1] == dat[:, 1]).all()
+        assert (d.section[0, 0] == dat[0, 0]).all()
+        assert (d.section[0, 1] == dat[0, 1]).all()
+        assert (d.section[1, 0] == dat[1, 0]).all()
+        assert (d.section[1, 1] == dat[1, 1]).all()
+        assert (d.section[0:1, 0:1] == dat[0:1, 0:1]).all()
+        assert (d.section[0:2, 0:1] == dat[0:2, 0:1]).all()
+        assert (d.section[0:1, 0:2] == dat[0:1, 0:2]).all()
+        assert (d.section[0:2, 0:2] == dat[0:2, 0:2]).all()
+        hdul.close()
+
+        # Test without having accessed the full data first
+        hdul = fits.open(self.data('scale.fits'))
+        d = hdul[0]
+        assert (d.section[:, :] == dat[:, :]).all()
+        assert (d.section[0, :] == dat[0, :]).all()
+        assert (d.section[1, :] == dat[1, :]).all()
+        assert (d.section[:, 0] == dat[:, 0]).all()
+        assert (d.section[:, 1] == dat[:, 1]).all()
+        assert (d.section[0, 0] == dat[0, 0]).all()
+        assert (d.section[0, 1] == dat[0, 1]).all()
+        assert (d.section[1, 0] == dat[1, 0]).all()
+        assert (d.section[1, 1] == dat[1, 1]).all()
+        assert (d.section[0:1, 0:1] == dat[0:1, 0:1]).all()
+        assert (d.section[0:2, 0:1] == dat[0:2, 0:1]).all()
+        assert (d.section[0:1, 0:2] == dat[0:1, 0:2]).all()
+        assert (d.section[0:2, 0:2] == dat[0:2, 0:2]).all()
+        assert not d._data_loaded
+        hdul.close()
+
+    def test_do_not_scale_image_data(self):
+        with fits.open(self.data('scale.fits'), do_not_scale_image_data=True) as hdul:
+            assert hdul[0].data.dtype == np.dtype('>i2')
+
+        with fits.open(self.data('scale.fits')) as hdul:
+            assert hdul[0].data.dtype == np.dtype('float32')
+
+    def test_append_uint_data(self):
+        """Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/56
+        (BZERO and BSCALE added in the wrong location when appending scaled
+        data)
+        """
+
+        fits.writeto(self.temp('test_new.fits'), data=np.array([],
+                     dtype='uint8'))
+        d = np.zeros([100, 100]).astype('uint16')
+        fits.append(self.temp('test_new.fits'), data=d)
+
+        with fits.open(self.temp('test_new.fits'), uint=True) as f:
+            assert f[1].data.dtype == 'uint16'
+
+    def test_scale_with_explicit_bzero_bscale(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/6399
+        """
+        hdu1 = fits.PrimaryHDU()
+        hdu2 = fits.ImageHDU(np.random.rand(100,100))
+        # The line below raised an exception in astropy 2.0, so if it does not
+        # raise an error here, that is progress.
+        hdu2.scale(type='uint8', bscale=1, bzero=0)
+
+    def test_uint_header_consistency(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/2305
+
+        This ensures that an HDU containing unsigned integer data always has
+        the apppriate BZERO value in its header.
+        """
+
+        for int_size in (16, 32, 64):
+            # Just make an array of some unsigned ints that wouldn't fit in a
+            # signed int array of the same bit width
+            max_uint = (2 ** int_size) - 1
+            if int_size == 64:
+                max_uint = np.uint64(int_size)
+
+            dtype = 'uint{}'.format(int_size)
+            arr = np.empty(100, dtype=dtype)
+            arr.fill(max_uint)
+            arr -= np.arange(100, dtype=dtype)
+
+            uint_hdu = fits.PrimaryHDU(data=arr)
+            assert np.all(uint_hdu.data == arr)
+            assert uint_hdu.data.dtype.name == 'uint{}'.format(int_size)
+            assert 'BZERO' in uint_hdu.header
+            assert uint_hdu.header['BZERO'] == (2 ** (int_size - 1))
+
+            filename = 'uint{}.fits'.format(int_size)
+            uint_hdu.writeto(self.temp(filename))
+
+            with fits.open(self.temp(filename), uint=True) as hdul:
+                new_uint_hdu = hdul[0]
+                assert np.all(new_uint_hdu.data == arr)
+                assert new_uint_hdu.data.dtype.name == 'uint{}'.format(int_size)
+                assert 'BZERO' in new_uint_hdu.header
+                assert new_uint_hdu.header['BZERO'] == (2 ** (int_size - 1))
+
+    @pytest.mark.parametrize(('from_file'), (False, True))
+    @pytest.mark.parametrize(('do_not_scale'), (False,))
+    def test_uint_header_keywords_removed_after_bitpix_change(self,
+                                                              from_file,
+                                                              do_not_scale):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/4974
+
+        BZERO/BSCALE should be removed if data is converted to a floating
+        point type.
+
+        Currently excluding the case where do_not_scale_image_data=True
+        because it is not clear what the expectation should be.
+        """
+
+        arr = np.zeros(100, dtype='uint16')
+
+        if from_file:
+            # To generate the proper input file we always want to scale the
+            # data before writing it...otherwise when we open it will be
+            # regular (signed) int data.
+            tmp_uint = fits.PrimaryHDU(arr)
+            filename = 'unsigned_int.fits'
+            tmp_uint.writeto(self.temp(filename))
+            with fits.open(self.temp(filename),
+                           do_not_scale_image_data=do_not_scale) as f:
+                uint_hdu = f[0]
+                # Force a read before we close.
+                _ = uint_hdu.data
+        else:
+            uint_hdu = fits.PrimaryHDU(arr,
+                                       do_not_scale_image_data=do_not_scale)
+
+        # Make sure appropriate keywords are in the header. See
+        # https://github.com/astropy/astropy/pull/3916#issuecomment-122414532
+        # for discussion.
+        assert 'BSCALE' in uint_hdu.header
+        assert 'BZERO' in uint_hdu.header
+        assert uint_hdu.header['BSCALE'] == 1
+        assert uint_hdu.header['BZERO'] == 32768
+
+        # Convert data to floating point...
+        uint_hdu.data = uint_hdu.data * 1.0
+
+        # ...bitpix should be negative.
+        assert uint_hdu.header['BITPIX'] < 0
+
+        # BSCALE and BZERO should NOT be in header any more.
+        assert 'BSCALE' not in uint_hdu.header
+        assert 'BZERO' not in uint_hdu.header
+
+        # This is the main test...the data values should round trip
+        # as zero.
+        filename = 'test_uint_to_float.fits'
+        uint_hdu.writeto(self.temp(filename))
+        with fits.open(self.temp(filename)) as hdul:
+            assert (hdul[0].data == 0).all()
+
+    def test_blanks(self):
+        """Test image data with blank spots in it (which should show up as
+        NaNs in the data array.
+        """
+
+        arr = np.zeros((10, 10), dtype=np.int32)
+        # One row will be blanks
+        arr[1] = 999
+        hdu = fits.ImageHDU(data=arr)
+        hdu.header['BLANK'] = 999
+        hdu.writeto(self.temp('test_new.fits'))
+
+        with fits.open(self.temp('test_new.fits')) as hdul:
+            assert np.isnan(hdul[1].data[1]).all()
+
+    def test_invalid_blanks(self):
+        """
+        Test that invalid use of the BLANK keyword leads to an appropriate
+        warning, and that the BLANK keyword is ignored when returning the
+        HDU data.
+
+        Regression test for https://github.com/astropy/astropy/issues/3865
+        """
+
+        arr = np.arange(5, dtype=np.float64)
+        hdu = fits.PrimaryHDU(data=arr)
+        hdu.header['BLANK'] = 2
+
+        with catch_warnings() as w:
+            hdu.writeto(self.temp('test_new.fits'))
+            # Allow the HDU to be written, but there should be a warning
+            # when writing a header with BLANK when then data is not
+            # int
+            assert len(w) == 1
+            assert "Invalid 'BLANK' keyword in header" in str(w[0].message)
+
+        # Should also get a warning when opening the file, and the BLANK
+        # value should not be applied
+        with catch_warnings() as w:
+            with fits.open(self.temp('test_new.fits')) as h:
+                assert len(w) == 1
+                assert "Invalid 'BLANK' keyword in header" in str(w[0].message)
+                assert np.all(arr == h[0].data)
+
+    def test_scale_back_with_blanks(self):
+        """
+        Test that when auto-rescaling integer data with "blank" values (where
+        the blanks are replaced by NaN in the float data), that the "BLANK"
+        keyword is removed from the header.
+
+        Further, test that when using the ``scale_back=True`` option the blank
+        values are restored properly.
+
+        Regression test for https://github.com/astropy/astropy/issues/3865
+        """
+
+        # Make the sample file
+        arr = np.arange(5, dtype=np.int32)
+        hdu = fits.PrimaryHDU(data=arr)
+        hdu.scale('int16', bscale=1.23)
+
+        # Creating data that uses BLANK is currently kludgy--a separate issue
+        # TODO: Rewrite this test when scaling with blank support is better
+        # supported
+
+        # Let's just add a value to the data that should be converted to NaN
+        # when it is read back in:
+        filename = self.temp('test.fits')
+        hdu.data[0] = 9999
+        hdu.header['BLANK'] = 9999
+        hdu.writeto(filename)
+
+        with fits.open(filename) as hdul:
+            data = hdul[0].data
+            assert np.isnan(data[0])
+            with pytest.warns(fits.verify.VerifyWarning,
+                              match="Invalid 'BLANK' keyword in header"):
+                hdul.writeto(self.temp('test2.fits'))
+
+        # Now reopen the newly written file.  It should not have a 'BLANK'
+        # keyword
+        with catch_warnings() as w:
+            with fits.open(self.temp('test2.fits')) as hdul2:
+                assert len(w) == 0
+                assert 'BLANK' not in hdul2[0].header
+                data = hdul2[0].data
+                assert np.isnan(data[0])
+
+        # Finally, test that scale_back keeps the BLANKs correctly
+        with fits.open(filename, scale_back=True,
+                       mode='update') as hdul3:
+            data = hdul3[0].data
+            assert np.isnan(data[0])
+
+        with fits.open(filename,
+                       do_not_scale_image_data=True) as hdul4:
+            assert hdul4[0].header['BLANK'] == 9999
+            assert hdul4[0].header['BSCALE'] == 1.23
+            assert hdul4[0].data[0] == 9999
+
+    def test_bzero_with_floats(self):
+        """Test use of the BZERO keyword in an image HDU containing float
+        data.
+        """
+
+        arr = np.zeros((10, 10)) - 1
+        hdu = fits.ImageHDU(data=arr)
+        hdu.header['BZERO'] = 1.0
+        hdu.writeto(self.temp('test_new.fits'))
+
+        with fits.open(self.temp('test_new.fits')) as hdul:
+            arr += 1
+            assert (hdul[1].data == arr).all()
+
+    def test_rewriting_large_scaled_image(self):
+        """Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/84 and
+        https://aeon.stsci.edu/ssb/trac/pyfits/ticket/101
+        """
+
+        hdul = fits.open(self.data('fixed-1890.fits'))
+        orig_data = hdul[0].data
+        with ignore_warnings():
+            hdul.writeto(self.temp('test_new.fits'), overwrite=True)
+        hdul.close()
+        hdul = fits.open(self.temp('test_new.fits'))
+        assert (hdul[0].data == orig_data).all()
+        hdul.close()
+
+        # Just as before, but this time don't touch hdul[0].data before writing
+        # back out--this is the case that failed in
+        # https://aeon.stsci.edu/ssb/trac/pyfits/ticket/84
+        hdul = fits.open(self.data('fixed-1890.fits'))
+        with ignore_warnings():
+            hdul.writeto(self.temp('test_new.fits'), overwrite=True)
+        hdul.close()
+        hdul = fits.open(self.temp('test_new.fits'))
+        assert (hdul[0].data == orig_data).all()
+        hdul.close()
+
+        # Test opening/closing/reopening a scaled file in update mode
+        hdul = fits.open(self.data('fixed-1890.fits'),
+                         do_not_scale_image_data=True)
+        hdul.writeto(self.temp('test_new.fits'), overwrite=True,
+                     output_verify='silentfix')
+        hdul.close()
+        hdul = fits.open(self.temp('test_new.fits'))
+        orig_data = hdul[0].data
+        hdul.close()
+        hdul = fits.open(self.temp('test_new.fits'), mode='update')
+        hdul.close()
+        hdul = fits.open(self.temp('test_new.fits'))
+        assert (hdul[0].data == orig_data).all()
+        hdul = fits.open(self.temp('test_new.fits'))
+        hdul.close()
+
+    def test_image_update_header(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/105
+
+        Replacing the original header to an image HDU and saving should update
+        the NAXISn keywords appropriately and save the image data correctly.
+        """
+
+        # Copy the original file before saving to it
+        self.copy_file('test0.fits')
+        with fits.open(self.temp('test0.fits'), mode='update') as hdul:
+            orig_data = hdul[1].data.copy()
+            hdr_copy = hdul[1].header.copy()
+            del hdr_copy['NAXIS*']
+            hdul[1].header = hdr_copy
+
+        with fits.open(self.temp('test0.fits')) as hdul:
+            assert (orig_data == hdul[1].data).all()
+
+    def test_open_scaled_in_update_mode(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/119
+        (Don't update scaled image data if the data is not read)
+
+        This ensures that merely opening and closing a file containing scaled
+        image data does not cause any change to the data (or the header).
+        Changes should only occur if the data is accessed.
+        """
+
+        # Copy the original file before making any possible changes to it
+        self.copy_file('scale.fits')
+        mtime = os.stat(self.temp('scale.fits')).st_mtime
+
+        time.sleep(1)
+
+        fits.open(self.temp('scale.fits'), mode='update').close()
+
+        # Ensure that no changes were made to the file merely by immediately
+        # opening and closing it.
+        assert mtime == os.stat(self.temp('scale.fits')).st_mtime
+
+        # Insert a slight delay to ensure the mtime does change when the file
+        # is changed
+        time.sleep(1)
+
+        hdul = fits.open(self.temp('scale.fits'), 'update')
+        orig_data = hdul[0].data
+        hdul.close()
+
+        # Now the file should be updated with the rescaled data
+        assert mtime != os.stat(self.temp('scale.fits')).st_mtime
+        hdul = fits.open(self.temp('scale.fits'), mode='update')
+        assert hdul[0].data.dtype == np.dtype('>f4')
+        assert hdul[0].header['BITPIX'] == -32
+        assert 'BZERO' not in hdul[0].header
+        assert 'BSCALE' not in hdul[0].header
+        assert (orig_data == hdul[0].data).all()
+
+        # Try reshaping the data, then closing and reopening the file; let's
+        # see if all the changes are preseved properly
+        hdul[0].data.shape = (42, 10)
+        hdul.close()
+
+        hdul = fits.open(self.temp('scale.fits'))
+        assert hdul[0].shape == (42, 10)
+        assert hdul[0].data.dtype == np.dtype('>f4')
+        assert hdul[0].header['BITPIX'] == -32
+        assert 'BZERO' not in hdul[0].header
+        assert 'BSCALE' not in hdul[0].header
+        hdul.close()
+
+    def test_scale_back(self):
+        """A simple test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/120
+
+        The scale_back feature for image HDUs.
+        """
+
+        self.copy_file('scale.fits')
+        with fits.open(self.temp('scale.fits'), mode='update',
+                       scale_back=True) as hdul:
+            orig_bitpix = hdul[0].header['BITPIX']
+            orig_bzero = hdul[0].header['BZERO']
+            orig_bscale = hdul[0].header['BSCALE']
+            orig_data = hdul[0].data.copy()
+            hdul[0].data[0] = 0
+
+        with fits.open(self.temp('scale.fits'),
+                       do_not_scale_image_data=True) as hdul:
+            assert hdul[0].header['BITPIX'] == orig_bitpix
+            assert hdul[0].header['BZERO'] == orig_bzero
+            assert hdul[0].header['BSCALE'] == orig_bscale
+
+            zero_point = int(math.floor(-orig_bzero / orig_bscale))
+            assert (hdul[0].data[0] == zero_point).all()
+
+        with fits.open(self.temp('scale.fits')) as hdul:
+            assert (hdul[0].data[1:] == orig_data[1:]).all()
+
+    def test_image_none(self):
+        """
+        Regression test for https://github.com/spacetelescope/PyFITS/issues/27
+        """
+
+        with fits.open(self.data('test0.fits')) as h:
+            h[1].data
+            h[1].data = None
+            h[1].writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits')) as h:
+            assert h[1].data is None
+            assert h[1].header['NAXIS'] == 0
+            assert 'NAXIS1' not in h[1].header
+            assert 'NAXIS2' not in h[1].header
+
+    def test_invalid_blank(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/2711
+
+        If the BLANK keyword contains an invalid value it should be ignored for
+        any calculations (though a warning should be issued).
+        """
+
+        data = np.arange(100, dtype=np.float64)
+        hdu = fits.PrimaryHDU(data)
+        hdu.header['BLANK'] = 'nan'
+        with pytest.warns(fits.verify.VerifyWarning, match="Invalid value for "
+                          "'BLANK' keyword in header: 'nan'"):
+            hdu.writeto(self.temp('test.fits'))
+
+        with catch_warnings() as w:
+            with fits.open(self.temp('test.fits')) as hdul:
+                assert np.all(hdul[0].data == data)
+
+        assert len(w) == 2
+        msg = "Invalid value for 'BLANK' keyword in header"
+        assert msg in str(w[0].message)
+        msg = "Invalid 'BLANK' keyword"
+        assert msg in str(w[1].message)
+
+    def test_scaled_image_fromfile(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/2710
+        """
+
+        # Make some sample data
+        a = np.arange(100, dtype=np.float32)
+
+        hdu = fits.PrimaryHDU(data=a.copy())
+        hdu.scale(bscale=1.1)
+        hdu.writeto(self.temp('test.fits'))
+
+        with open(self.temp('test.fits'), 'rb') as f:
+            file_data = f.read()
+
+        hdul = fits.HDUList.fromstring(file_data)
+        assert np.allclose(hdul[0].data, a)
+
+    def test_set_data(self):
+        """
+        Test data assignment - issue #5087
+        """
+
+        im = fits.ImageHDU()
+        ar = np.arange(12)
+        im.data = ar
+
+    def test_scale_bzero_with_int_data(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/4600
+        """
+
+        a = np.arange(100, 200, dtype=np.int16)
+
+        hdu1 = fits.PrimaryHDU(data=a.copy())
+        hdu2 = fits.PrimaryHDU(data=a.copy())
+        # Previously the following line would throw a TypeError,
+        # now it should be identical to the integer bzero case
+        hdu1.scale('int16', bzero=99.0)
+        hdu2.scale('int16', bzero=99)
+        assert np.allclose(hdu1.data, hdu2.data)
+
+    def test_scale_back_uint_assignment(self):
+        """
+        Extend fix for #4600 to assignment to data
+
+        Suggested by:
+        https://github.com/astropy/astropy/pull/4602#issuecomment-208713748
+        """
+
+        a = np.arange(100, 200, dtype=np.uint16)
+        fits.PrimaryHDU(a).writeto(self.temp('test.fits'))
+        with fits.open(self.temp('test.fits'), mode="update",
+                       scale_back=True) as (hdu,):
+            hdu.data[:] = 0
+            assert np.allclose(hdu.data, 0)
+
+
+class TestCompressedImage(FitsTestCase):
+    def test_empty(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/2595
+        """
+
+        hdu = fits.CompImageHDU()
+        assert hdu.data is None
+        hdu.writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits'), mode='update') as hdul:
+            assert len(hdul) == 2
+            assert isinstance(hdul[1], fits.CompImageHDU)
+            assert hdul[1].data is None
+
+            # Now test replacing the empty data with an array and see what
+            # happens
+            hdul[1].data = np.arange(100, dtype=np.int32)
+
+        with fits.open(self.temp('test.fits')) as hdul:
+            assert len(hdul) == 2
+            assert isinstance(hdul[1], fits.CompImageHDU)
+            assert np.all(hdul[1].data == np.arange(100, dtype=np.int32))
+
+    @pytest.mark.parametrize(
+        ('data', 'compression_type', 'quantize_level'),
+        [(np.zeros((2, 10, 10), dtype=np.float32), 'RICE_1', 16),
+         (np.zeros((2, 10, 10), dtype=np.float32), 'GZIP_1', -0.01),
+         (np.zeros((2, 10, 10), dtype=np.float32), 'GZIP_2', -0.01),
+         (np.zeros((100, 100)) + 1, 'HCOMPRESS_1', 16),
+         (np.zeros((10, 10)), 'PLIO_1', 16)])
+    @pytest.mark.parametrize('byte_order', ['<', '>'])
+    def test_comp_image(self, data, compression_type, quantize_level,
+                        byte_order):
+        data = data.newbyteorder(byte_order)
+        primary_hdu = fits.PrimaryHDU()
+        ofd = fits.HDUList(primary_hdu)
+        chdu = fits.CompImageHDU(data, name='SCI',
+                                 compression_type=compression_type,
+                                 quantize_level=quantize_level)
+        ofd.append(chdu)
+        ofd.writeto(self.temp('test_new.fits'), overwrite=True)
+        ofd.close()
+        with fits.open(self.temp('test_new.fits')) as fd:
+            assert (fd[1].data == data).all()
+            assert fd[1].header['NAXIS'] == chdu.header['NAXIS']
+            assert fd[1].header['NAXIS1'] == chdu.header['NAXIS1']
+            assert fd[1].header['NAXIS2'] == chdu.header['NAXIS2']
+            assert fd[1].header['BITPIX'] == chdu.header['BITPIX']
+
+    @pytest.mark.skipif('not HAS_SCIPY')
+    def test_comp_image_quantize_level(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/5969
+
+        Test that quantize_level is used.
+
+        """
+        import scipy.misc
+        np.random.seed(42)
+        data = scipy.misc.ascent() + np.random.randn(512, 512)*10
+
+        fits.ImageHDU(data).writeto(self.temp('im1.fits'))
+        fits.CompImageHDU(data, compression_type='RICE_1', quantize_method=1,
+                          quantize_level=-1, dither_seed=5)\
+            .writeto(self.temp('im2.fits'))
+        fits.CompImageHDU(data, compression_type='RICE_1', quantize_method=1,
+                          quantize_level=-100, dither_seed=5)\
+            .writeto(self.temp('im3.fits'))
+
+        im1 = fits.getdata(self.temp('im1.fits'))
+        im2 = fits.getdata(self.temp('im2.fits'))
+        im3 = fits.getdata(self.temp('im3.fits'))
+
+        assert not np.array_equal(im2, im3)
+        assert np.isclose(np.min(im1 - im2), -0.5, atol=1e-3)
+        assert np.isclose(np.max(im1 - im2), 0.5, atol=1e-3)
+        assert np.isclose(np.min(im1 - im3), -50, atol=1e-1)
+        assert np.isclose(np.max(im1 - im3), 50, atol=1e-1)
+
+    def test_comp_image_hcompression_1_invalid_data(self):
+        """
+        Tests compression with the HCOMPRESS_1 algorithm with data that is
+        not 2D and has a non-2D tile size.
+        """
+
+        pytest.raises(ValueError, fits.CompImageHDU,
+                      np.zeros((2, 10, 10), dtype=np.float32), name='SCI',
+                      compression_type='HCOMPRESS_1', quantize_level=16,
+                      tile_size=[2, 10, 10])
+
+    def test_comp_image_hcompress_image_stack(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/171
+
+        Tests that data containing more than two dimensions can be
+        compressed with HCOMPRESS_1 so long as the user-supplied tile size can
+        be flattened to two dimensions.
+        """
+
+        cube = np.arange(300, dtype=np.float32).reshape(3, 10, 10)
+        hdu = fits.CompImageHDU(data=cube, name='SCI',
+                                compression_type='HCOMPRESS_1',
+                                quantize_level=16, tile_size=[5, 5, 1])
+        hdu.writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits')) as hdul:
+            # HCOMPRESSed images are allowed to deviate from the original by
+            # about 1/quantize_level of the RMS in each tile.
+            assert np.abs(hdul['SCI'].data - cube).max() < 1./15.
+
+    def test_subtractive_dither_seed(self):
+        """
+        Regression test for https://github.com/spacetelescope/PyFITS/issues/32
+
+        Ensure that when floating point data is compressed with the
+        SUBTRACTIVE_DITHER_1 quantization method that the correct ZDITHER0 seed
+        is added to the header, and that the data can be correctly
+        decompressed.
+        """
+
+        array = np.arange(100.0).reshape(10, 10)
+        csum = (array[0].view('uint8').sum() % 10000) + 1
+        hdu = fits.CompImageHDU(data=array,
+                                quantize_method=SUBTRACTIVE_DITHER_1,
+                                dither_seed=DITHER_SEED_CHECKSUM)
+        hdu.writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits')) as hdul:
+            assert isinstance(hdul[1], fits.CompImageHDU)
+            assert 'ZQUANTIZ' in hdul[1]._header
+            assert hdul[1]._header['ZQUANTIZ'] == 'SUBTRACTIVE_DITHER_1'
+            assert 'ZDITHER0' in hdul[1]._header
+            assert hdul[1]._header['ZDITHER0'] == csum
+            assert np.all(hdul[1].data == array)
+
+    def test_disable_image_compression(self):
+        with catch_warnings():
+            # No warnings should be displayed in this case
+            warnings.simplefilter('error')
+            with fits.open(self.data('comp.fits'),
+                           disable_image_compression=True) as hdul:
+                # The compressed image HDU should show up as a BinTableHDU, but
+                # *not* a CompImageHDU
+                assert isinstance(hdul[1], fits.BinTableHDU)
+                assert not isinstance(hdul[1], fits.CompImageHDU)
+
+        with fits.open(self.data('comp.fits')) as hdul:
+            assert isinstance(hdul[1], fits.CompImageHDU)
+
+    def test_open_comp_image_in_update_mode(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/167
+
+        Similar to test_open_scaled_in_update_mode(), but specifically for
+        compressed images.
+        """
+
+        # Copy the original file before making any possible changes to it
+        self.copy_file('comp.fits')
+        mtime = os.stat(self.temp('comp.fits')).st_mtime
+
+        time.sleep(1)
+
+        fits.open(self.temp('comp.fits'), mode='update').close()
+
+        # Ensure that no changes were made to the file merely by immediately
+        # opening and closing it.
+        assert mtime == os.stat(self.temp('comp.fits')).st_mtime
+
+    def test_open_scaled_in_update_mode_compressed(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/88 2
+
+        Identical to test_open_scaled_in_update_mode() but with a compressed
+        version of the scaled image.
+        """
+
+        # Copy+compress the original file before making any possible changes to
+        # it
+        with fits.open(self.data('scale.fits'),
+                       do_not_scale_image_data=True) as hdul:
+            chdu = fits.CompImageHDU(data=hdul[0].data,
+                                     header=hdul[0].header)
+            chdu.writeto(self.temp('scale.fits'))
+        mtime = os.stat(self.temp('scale.fits')).st_mtime
+
+        time.sleep(1)
+
+        fits.open(self.temp('scale.fits'), mode='update').close()
+
+        # Ensure that no changes were made to the file merely by immediately
+        # opening and closing it.
+        assert mtime == os.stat(self.temp('scale.fits')).st_mtime
+
+        # Insert a slight delay to ensure the mtime does change when the file
+        # is changed
+        time.sleep(1)
+
+        hdul = fits.open(self.temp('scale.fits'), 'update')
+        hdul[1].data
+        hdul.close()
+
+        # Now the file should be updated with the rescaled data
+        assert mtime != os.stat(self.temp('scale.fits')).st_mtime
+        hdul = fits.open(self.temp('scale.fits'), mode='update')
+        assert hdul[1].data.dtype == np.dtype('float32')
+        assert hdul[1].header['BITPIX'] == -32
+        assert 'BZERO' not in hdul[1].header
+        assert 'BSCALE' not in hdul[1].header
+
+        # Try reshaping the data, then closing and reopening the file; let's
+        # see if all the changes are preseved properly
+        hdul[1].data.shape = (42, 10)
+        hdul.close()
+
+        hdul = fits.open(self.temp('scale.fits'))
+        assert hdul[1].shape == (42, 10)
+        assert hdul[1].data.dtype == np.dtype('float32')
+        assert hdul[1].header['BITPIX'] == -32
+        assert 'BZERO' not in hdul[1].header
+        assert 'BSCALE' not in hdul[1].header
+        hdul.close()
+
+    def test_write_comp_hdu_direct_from_existing(self):
+        with fits.open(self.data('comp.fits')) as hdul:
+            hdul[1].writeto(self.temp('test.fits'))
+
+        with fits.open(self.data('comp.fits')) as hdul1:
+            with fits.open(self.temp('test.fits')) as hdul2:
+                assert np.all(hdul1[1].data == hdul2[1].data)
+                assert comparerecords(hdul1[1].compressed_data,
+                                      hdul2[1].compressed_data)
+
+    def test_rewriting_large_scaled_image_compressed(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/88 1
+
+        Identical to test_rewriting_large_scaled_image() but with a compressed
+        image.
+        """
+
+        with fits.open(self.data('fixed-1890.fits'),
+                       do_not_scale_image_data=True) as hdul:
+            chdu = fits.CompImageHDU(data=hdul[0].data,
+                                     header=hdul[0].header)
+            chdu.writeto(self.temp('fixed-1890-z.fits'))
+
+        hdul = fits.open(self.temp('fixed-1890-z.fits'))
+        orig_data = hdul[1].data
+        with ignore_warnings():
+            hdul.writeto(self.temp('test_new.fits'), overwrite=True)
+        hdul.close()
+        hdul = fits.open(self.temp('test_new.fits'))
+        assert (hdul[1].data == orig_data).all()
+        hdul.close()
+
+        # Just as before, but this time don't touch hdul[0].data before writing
+        # back out--this is the case that failed in
+        # https://aeon.stsci.edu/ssb/trac/pyfits/ticket/84
+        hdul = fits.open(self.temp('fixed-1890-z.fits'))
+        with ignore_warnings():
+            hdul.writeto(self.temp('test_new.fits'), overwrite=True)
+        hdul.close()
+        hdul = fits.open(self.temp('test_new.fits'))
+        assert (hdul[1].data == orig_data).all()
+        hdul.close()
+
+        # Test opening/closing/reopening a scaled file in update mode
+        hdul = fits.open(self.temp('fixed-1890-z.fits'),
+                         do_not_scale_image_data=True)
+        hdul.writeto(self.temp('test_new.fits'), overwrite=True,
+                     output_verify='silentfix')
+        hdul.close()
+        hdul = fits.open(self.temp('test_new.fits'))
+        orig_data = hdul[1].data
+        hdul.close()
+        hdul = fits.open(self.temp('test_new.fits'), mode='update')
+        hdul.close()
+        hdul = fits.open(self.temp('test_new.fits'))
+        assert (hdul[1].data == orig_data).all()
+        hdul = fits.open(self.temp('test_new.fits'))
+        hdul.close()
+
+    def test_scale_back_compressed(self):
+        """
+        Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/88 3
+
+        Identical to test_scale_back() but uses a compressed image.
+        """
+
+        # Create a compressed version of the scaled image
+        with fits.open(self.data('scale.fits'),
+                       do_not_scale_image_data=True) as hdul:
+            chdu = fits.CompImageHDU(data=hdul[0].data,
+                                     header=hdul[0].header)
+            chdu.writeto(self.temp('scale.fits'))
+
+        with fits.open(self.temp('scale.fits'), mode='update',
+                       scale_back=True) as hdul:
+            orig_bitpix = hdul[1].header['BITPIX']
+            orig_bzero = hdul[1].header['BZERO']
+            orig_bscale = hdul[1].header['BSCALE']
+            orig_data = hdul[1].data.copy()
+            hdul[1].data[0] = 0
+
+        with fits.open(self.temp('scale.fits'),
+                       do_not_scale_image_data=True) as hdul:
+            assert hdul[1].header['BITPIX'] == orig_bitpix
+            assert hdul[1].header['BZERO'] == orig_bzero
+            assert hdul[1].header['BSCALE'] == orig_bscale
+
+            zero_point = int(math.floor(-orig_bzero / orig_bscale))
+            assert (hdul[1].data[0] == zero_point).all()
+
+        with fits.open(self.temp('scale.fits')) as hdul:
+            assert (hdul[1].data[1:] == orig_data[1:]).all()
+            # Extra test to ensure that after everything the data is still the
+            # same as in the original uncompressed version of the image
+            with fits.open(self.data('scale.fits')) as hdul2:
+                # Recall we made the same modification to the data in hdul
+                # above
+                hdul2[0].data[0] = 0
+                assert (hdul[1].data == hdul2[0].data).all()
+
+    def test_lossless_gzip_compression(self):
+        """Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/198"""
+
+        noise = np.random.normal(size=(1000, 1000))
+
+        chdu1 = fits.CompImageHDU(data=noise, compression_type='GZIP_1')
+        # First make a test image with lossy compression and make sure it
+        # wasn't compressed perfectly.  This shouldn't happen ever, but just to
+        # make sure the test non-trivial.
+        chdu1.writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits')) as h:
+            assert np.abs(noise - h[1].data).max() > 0.0
+
+        del h
+
+        chdu2 = fits.CompImageHDU(data=noise, compression_type='GZIP_1',
+                                  quantize_level=0.0)  # No quantization
+        with ignore_warnings():
+            chdu2.writeto(self.temp('test.fits'), overwrite=True)
+
+        with fits.open(self.temp('test.fits')) as h:
+            assert (noise == h[1].data).all()
+
+    def test_compression_column_tforms(self):
+        """Regression test for https://aeon.stsci.edu/ssb/trac/pyfits/ticket/199"""
+
+        # Some interestingly tiled data so that some of it is quantized and
+        # some of it ends up just getting gzip-compressed
+        data2 = ((np.arange(1, 8, dtype=np.float32) * 10)[:, np.newaxis] +
+                 np.arange(1, 7))
+        np.random.seed(1337)
+        data1 = np.random.uniform(size=(6 * 4, 7 * 4))
+        data1[:data2.shape[0], :data2.shape[1]] = data2
+        chdu = fits.CompImageHDU(data1, compression_type='RICE_1',
+                                 tile_size=(6, 7))
+        chdu.writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits'),
+                       disable_image_compression=True) as h:
+            assert re.match(r'^1PB\(\d+\)$', h[1].header['TFORM1'])
+            assert re.match(r'^1PB\(\d+\)$', h[1].header['TFORM2'])
+
+    def test_compression_update_header(self):
+        """Regression test for
+        https://github.com/spacetelescope/PyFITS/issues/23
+        """
+
+        self.copy_file('comp.fits')
+        with fits.open(self.temp('comp.fits'), mode='update') as hdul:
+            assert isinstance(hdul[1], fits.CompImageHDU)
+            hdul[1].header['test1'] = 'test'
+            hdul[1]._header['test2'] = 'test2'
+
+        with fits.open(self.temp('comp.fits')) as hdul:
+            assert 'test1' in hdul[1].header
+            assert hdul[1].header['test1'] == 'test'
+            assert 'test2' in hdul[1].header
+            assert hdul[1].header['test2'] == 'test2'
+
+        # Test update via index now:
+        with fits.open(self.temp('comp.fits'), mode='update') as hdul:
+            hdr = hdul[1].header
+            hdr[hdr.index('TEST1')] = 'foo'
+
+        with fits.open(self.temp('comp.fits')) as hdul:
+            assert hdul[1].header['TEST1'] == 'foo'
+
+        # Test slice updates
+        with fits.open(self.temp('comp.fits'), mode='update') as hdul:
+            hdul[1].header['TEST*'] = 'qux'
+
+        with fits.open(self.temp('comp.fits')) as hdul:
+            assert list(hdul[1].header['TEST*'].values()) == ['qux', 'qux']
+
+        with fits.open(self.temp('comp.fits'), mode='update') as hdul:
+            hdr = hdul[1].header
+            idx = hdr.index('TEST1')
+            hdr[idx:idx + 2] = 'bar'
+
+        with fits.open(self.temp('comp.fits')) as hdul:
+            assert list(hdul[1].header['TEST*'].values()) == ['bar', 'bar']
+
+        # Test updating a specific COMMENT card duplicate
+        with fits.open(self.temp('comp.fits'), mode='update') as hdul:
+            hdul[1].header[('COMMENT', 1)] = 'I am fire. I am death!'
+
+        with fits.open(self.temp('comp.fits')) as hdul:
+            assert hdul[1].header['COMMENT'][1] == 'I am fire. I am death!'
+            assert hdul[1]._header['COMMENT'][1] == 'I am fire. I am death!'
+
+        # Test deleting by keyword and by slice
+        with fits.open(self.temp('comp.fits'), mode='update') as hdul:
+            hdr = hdul[1].header
+            del hdr['COMMENT']
+            idx = hdr.index('TEST1')
+            del hdr[idx:idx + 2]
+
+        with fits.open(self.temp('comp.fits')) as hdul:
+            assert 'COMMENT' not in hdul[1].header
+            assert 'COMMENT' not in hdul[1]._header
+            assert 'TEST1' not in hdul[1].header
+            assert 'TEST1' not in hdul[1]._header
+            assert 'TEST2' not in hdul[1].header
+            assert 'TEST2' not in hdul[1]._header
+
+    def test_compression_update_header_with_reserved(self):
+        """
+        Ensure that setting reserved keywords related to the table data
+        structure on CompImageHDU image headers fails.
+        """
+
+        def test_set_keyword(hdr, keyword, value):
+            with catch_warnings() as w:
+                hdr[keyword] = value
+                assert len(w) == 1
+                assert str(w[0].message).startswith(
+                        "Keyword {!r} is reserved".format(keyword))
+                assert keyword not in hdr
+
+        with fits.open(self.data('comp.fits')) as hdul:
+            hdr = hdul[1].header
+            test_set_keyword(hdr, 'TFIELDS', 8)
+            test_set_keyword(hdr, 'TTYPE1', 'Foo')
+            test_set_keyword(hdr, 'ZCMPTYPE', 'ASDF')
+            test_set_keyword(hdr, 'ZVAL1', 'Foo')
+
+    def test_compression_header_append(self):
+        with fits.open(self.data('comp.fits')) as hdul:
+            imghdr = hdul[1].header
+            tblhdr = hdul[1]._header
+            with catch_warnings() as w:
+                imghdr.append('TFIELDS')
+                assert len(w) == 1
+                assert 'TFIELDS' not in imghdr
+
+            imghdr.append(('FOO', 'bar', 'qux'), end=True)
+            assert 'FOO' in imghdr
+            assert imghdr[-1] == 'bar'
+            assert 'FOO' in tblhdr
+            assert tblhdr[-1] == 'bar'
+
+            imghdr.append(('CHECKSUM', 'abcd1234'))
+            assert 'CHECKSUM' in imghdr
+            assert imghdr['CHECKSUM'] == 'abcd1234'
+            assert 'CHECKSUM' not in tblhdr
+            assert 'ZHECKSUM' in tblhdr
+            assert tblhdr['ZHECKSUM'] == 'abcd1234'
+
+    def test_compression_header_append2(self):
+        """
+        Regresion test for issue https://github.com/astropy/astropy/issues/5827
+        """
+        with fits.open(self.data('comp.fits')) as hdul:
+            header = hdul[1].header
+            while (len(header) < 1000):
+                header.append()    # pad with grow room
+
+            # Append stats to header:
+            header.append(("Q1_OSAVG", 1, "[adu] quadrant 1 overscan mean"))
+            header.append(("Q1_OSSTD", 1, "[adu] quadrant 1 overscan stddev"))
+            header.append(("Q1_OSMED", 1, "[adu] quadrant 1 overscan median"))
+
+    def test_compression_header_insert(self):
+        with fits.open(self.data('comp.fits')) as hdul:
+            imghdr = hdul[1].header
+            tblhdr = hdul[1]._header
+            # First try inserting a restricted keyword
+            with catch_warnings() as w:
+                imghdr.insert(1000, 'TFIELDS')
+                assert len(w) == 1
+                assert 'TFIELDS' not in imghdr
+                assert tblhdr.count('TFIELDS') == 1
+
+            # First try keyword-relative insert
+            imghdr.insert('TELESCOP', ('OBSERVER', 'Phil Plait'))
+            assert 'OBSERVER' in imghdr
+            assert imghdr.index('OBSERVER') == imghdr.index('TELESCOP') - 1
+            assert 'OBSERVER' in tblhdr
+            assert tblhdr.index('OBSERVER') == tblhdr.index('TELESCOP') - 1
+
+            # Next let's see if an index-relative insert winds up being
+            # sensible
+            idx = imghdr.index('OBSERVER')
+            imghdr.insert('OBSERVER', ('FOO',))
+            assert 'FOO' in imghdr
+            assert imghdr.index('FOO') == idx
+            assert 'FOO' in tblhdr
+            assert tblhdr.index('FOO') == tblhdr.index('OBSERVER') - 1
+
+    def test_compression_header_set_before_after(self):
+        with fits.open(self.data('comp.fits')) as hdul:
+            imghdr = hdul[1].header
+            tblhdr = hdul[1]._header
+
+            with catch_warnings() as w:
+                imghdr.set('ZBITPIX', 77, 'asdf', after='XTENSION')
+                assert len(w) == 1
+                assert 'ZBITPIX' not in imghdr
+                assert tblhdr.count('ZBITPIX') == 1
+                assert tblhdr['ZBITPIX'] != 77
+
+            # Move GCOUNT before PCOUNT (not that there's any reason you'd
+            # *want* to do that, but it's just a test...)
+            imghdr.set('GCOUNT', 99, before='PCOUNT')
+            assert imghdr.index('GCOUNT') == imghdr.index('PCOUNT') - 1
+            assert imghdr['GCOUNT'] == 99
+            assert tblhdr.index('ZGCOUNT') == tblhdr.index('ZPCOUNT') - 1
+            assert tblhdr['ZGCOUNT'] == 99
+            assert tblhdr.index('PCOUNT') == 5
+            assert tblhdr.index('GCOUNT') == 6
+            assert tblhdr['GCOUNT'] == 1
+
+            imghdr.set('GCOUNT', 2, after='PCOUNT')
+            assert imghdr.index('GCOUNT') == imghdr.index('PCOUNT') + 1
+            assert imghdr['GCOUNT'] == 2
+            assert tblhdr.index('ZGCOUNT') == tblhdr.index('ZPCOUNT') + 1
+            assert tblhdr['ZGCOUNT'] == 2
+            assert tblhdr.index('PCOUNT') == 5
+            assert tblhdr.index('GCOUNT') == 6
+            assert tblhdr['GCOUNT'] == 1
+
+    def test_compression_header_append_commentary(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/2363
+        """
+
+        hdu = fits.CompImageHDU(np.array([0], dtype=np.int32))
+        hdu.header['COMMENT'] = 'hello world'
+        assert hdu.header['COMMENT'] == ['hello world']
+        hdu.writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits')) as hdul:
+            assert hdul[1].header['COMMENT'] == ['hello world']
+
+    def test_compression_with_gzip_column(self):
+        """
+        Regression test for https://github.com/spacetelescope/PyFITS/issues/71
+        """
+
+        arr = np.zeros((2, 7000), dtype='float32')
+
+        # The first row (which will be the first compressed tile) has a very
+        # wide range of values that will be difficult to quantize, and should
+        # result in use of a GZIP_COMPRESSED_DATA column
+        arr[0] = np.linspace(0, 1, 7000)
+        arr[1] = np.random.normal(size=7000)
+
+        hdu = fits.CompImageHDU(data=arr)
+        hdu.writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits')) as hdul:
+            comp_hdu = hdul[1]
+
+            # GZIP-compressed tile should compare exactly
+            assert np.all(comp_hdu.data[0] == arr[0])
+            # The second tile uses lossy compression and may be somewhat off,
+            # so we don't bother comparing it exactly
+
+    def test_duplicate_compression_header_keywords(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/2750
+
+        Tests that the fake header (for the compressed image) can still be read
+        even if the real header contained a duplicate ZTENSION keyword (the
+        issue applies to any keyword specific to the compression convention,
+        however).
+        """
+
+        arr = np.arange(100, dtype=np.int32)
+        hdu = fits.CompImageHDU(data=arr)
+
+        header = hdu._header
+        # append the duplicate keyword
+        hdu._header.append(('ZTENSION', 'IMAGE'))
+        hdu.writeto(self.temp('test.fits'))
+
+        with fits.open(self.temp('test.fits')) as hdul:
+            assert header == hdul[1]._header
+            # There's no good reason to have a duplicate keyword, but
+            # technically it isn't invalid either :/
+            assert hdul[1]._header.count('ZTENSION') == 2
+
+    def test_scale_bzero_with_compressed_int_data(self):
+        """
+        Regression test for https://github.com/astropy/astropy/issues/4600
+        and https://github.com/astropy/astropy/issues/4588
+
+        Identical to test_scale_bzero_with_int_data() but uses a compressed
+        image.
+        """
+
+        a = np.arange(100, 200, dtype=np.int16)
+
+        hdu1 = fits.CompImageHDU(data=a.copy())
+        hdu2 = fits.CompImageHDU(data=a.copy())
+        # Previously the following line would throw a TypeError,
+        # now it should be identical to the integer bzero case
+        hdu1.scale('int16', bzero=99.0)
+        hdu2.scale('int16', bzero=99)
+        assert np.allclose(hdu1.data, hdu2.data)
+
+    def test_scale_back_compressed_uint_assignment(self):
+        """
+        Extend fix for #4600 to assignment to data
+
+        Identical to test_scale_back_uint_assignment() but uses a compressed
+        image.
+
+        Suggested by:
+        https://github.com/astropy/astropy/pull/4602#issuecomment-208713748
+        """
+
+        a = np.arange(100, 200, dtype=np.uint16)
+        fits.CompImageHDU(a).writeto(self.temp('test.fits'))
+        with fits.open(self.temp('test.fits'), mode="update",
+                       scale_back=True) as hdul:
+            hdul[1].data[:] = 0
+            assert np.allclose(hdul[1].data, 0)
+
+    def test_compressed_header_missing_znaxis(self):
+        a = np.arange(100, 200, dtype=np.uint16)
+        comp_hdu = fits.CompImageHDU(a)
+        comp_hdu._header.pop('ZNAXIS')
+        with pytest.raises(KeyError):
+            comp_hdu.compressed_data
+        comp_hdu = fits.CompImageHDU(a)
+        comp_hdu._header.pop('ZBITPIX')
+        with pytest.raises(KeyError):
+            comp_hdu.compressed_data
+
+    @pytest.mark.parametrize(
+        ('keyword', 'dtype', 'expected'),
+        [('BSCALE', np.uint8, np.float32), ('BSCALE', np.int16, np.float32),
+         ('BSCALE', np.int32, np.float64), ('BZERO', np.uint8, np.float32),
+         ('BZERO', np.int16, np.float32), ('BZERO', np.int32, np.float64)])
+    def test_compressed_scaled_float(self, keyword, dtype, expected):
+        """
+        If BSCALE,BZERO is set to floating point values, the image
+        should be floating-point.
+
+        https://github.com/astropy/astropy/pull/6492
+
+        Parameters
+        ----------
+        keyword : `str`
+            Keyword to set to a floating-point value to trigger
+            floating-point pixels.
+        dtype : `numpy.dtype`
+            Type of original array.
+        expected : `numpy.dtype`
+            Expected type of uncompressed array.
+        """
+        value = 1.23345  # A floating-point value
+        hdu = fits.CompImageHDU(np.arange(0, 10, dtype=dtype))
+        hdu.header[keyword] = value
+        hdu.writeto(self.temp('test.fits'))
+        del hdu
+        with fits.open(self.temp('test.fits')) as hdu:
+            assert hdu[1].header[keyword] == value
+            assert hdu[1].data.dtype == expected
+
+
+def test_comphdu_bscale(tmpdir):
+    """
+    Regression test for a bug that caused extensions that used BZERO and BSCALE
+    that got turned into CompImageHDU to end up with BZERO/BSCALE before the
+    TFIELDS.
+    """
+
+    filename1 = tmpdir.join('3hdus.fits').strpath
+    filename2 = tmpdir.join('3hdus_comp.fits').strpath
+
+    x = np.random.random((100, 100))*100
+
+    x0 = fits.PrimaryHDU()
+    x1 = fits.ImageHDU(np.array(x-50, dtype=int), uint=True)
+    x1.header['BZERO'] = 20331
+    x1.header['BSCALE'] = 2.3
+    hdus = fits.HDUList([x0, x1])
+    hdus.writeto(filename1)
+
+    # fitsverify (based on cfitsio) should fail on this file, only seeing the
+    # first HDU.
+    with fits.open(filename1) as hdus:
+        hdus[1] = fits.CompImageHDU(data=hdus[1].data.astype(np.uint32),
+                                    header=hdus[1].header)
+        hdus.writeto(filename2)
+
+    # open again and verify
+    with fits.open(filename2) as hdus:
+        hdus[1].verify('exception')
+
+
+def test_scale_implicit_casting():
+
+    # Regression test for an issue that occurred because Numpy now does not
+    # allow implicit type casting during inplace operations.
+
+    hdu = fits.ImageHDU(np.array([1], dtype=np.int32))
+    hdu.scale(bzero=1.3)
+
+
+def test_bzero_implicit_casting_compressed():
+
+    # Regression test for an issue that occurred because Numpy now does not
+    # allow implicit type casting during inplace operations. Astropy is
+    # actually not able to produce a file that triggers the failure - the
+    # issue occurs when using unsigned integer types in the FITS file, in which
+    # case BZERO should be 32768. But if the keyword is stored as 32768.0, then
+    # it was possible to trigger the implicit casting error.
+
+    filename = os.path.join(os.path.dirname(__file__),
+                            'data', 'compressed_float_bzero.fits')
+
+    with fits.open(filename) as hdul:
+        hdu = hdul[1]
+        hdu.data
+
+
+def test_bzero_mishandled_info(tmpdir):
+    # Regression test for #5507:
+    # Calling HDUList.info() on a dataset which applies a zeropoint
+    # from BZERO but which astropy.io.fits does not think it needs
+    # to resize to a new dtype results in an AttributeError.
+    filename = tmpdir.join('floatimg_with_bzero.fits').strpath
+    hdu = fits.ImageHDU(np.zeros((10, 10)))
+    hdu.header['BZERO'] = 10
+    hdu.writeto(filename, overwrite=True)
+    with fits.open(filename) as hdul:
+        hdul.info()
+
+
+def test_image_write_readonly(tmpdir):
+
+    # Regression test to make sure that we can write out read-only arrays (#5512)
+
+    x = np.array([1, 2, 3])
+    x.setflags(write=False)
+    ghdu = fits.ImageHDU(data=x)
+    ghdu.add_datasum()
+
+    filename = tmpdir.join('test.fits').strpath
+
+    ghdu.writeto(filename)
+
+    with fits.open(filename) as hdulist:
+        assert_equal(hdulist[1].data, [1, 2, 3])
+
+    # Same for compressed HDU
+    x = np.array([1.0, 2.0, 3.0])
+    x.setflags(write=False)
+    ghdu = fits.CompImageHDU(data=x)
+    # add_datasum does not work for CompImageHDU
+    # ghdu.add_datasum()
+
+    filename = tmpdir.join('test2.fits').strpath
+
+    ghdu.writeto(filename)
+
+    with fits.open(filename) as hdulist:
+        assert_equal(hdulist[1].data, [1.0, 2.0, 3.0])

testbed/astropy__astropy/astropy/io/fits/tests/test_nonstandard.py

@@ -0,0 +1,69 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import numpy as np
+
+from astropy.io import fits
+from . import FitsTestCase
+
+
+class TestNonstandardHdus(FitsTestCase):
+    def test_create_fitshdu(self):
+        """
+        A round trip test of creating a FitsHDU, adding a FITS file to it,
+        writing the FitsHDU out as part of a new FITS file, and then reading
+        it and recovering the original FITS file.
+        """
+
+        self._test_create_fitshdu(compression=False)
+
+    def test_create_fitshdu_with_compression(self):
+        """Same as test_create_fitshdu but with gzip compression enabled."""
+
+        self._test_create_fitshdu(compression=True)
+
+    def test_create_fitshdu_from_filename(self):
+        """Regression test on `FitsHDU.fromfile`"""
+
+        # Build up a simple test FITS file
+        a = np.arange(100)
+        phdu = fits.PrimaryHDU(data=a)
+        phdu.header['TEST1'] = 'A'
+        phdu.header['TEST2'] = 'B'
+        imghdu = fits.ImageHDU(data=a + 1)
+        phdu.header['TEST3'] = 'C'
+        phdu.header['TEST4'] = 'D'
+
+        hdul = fits.HDUList([phdu, imghdu])
+        hdul.writeto(self.temp('test.fits'))
+
+        fitshdu = fits.FitsHDU.fromfile(self.temp('test.fits'))
+        hdul2 = fitshdu.hdulist
+
+        assert len(hdul2) == 2
+        assert fits.FITSDiff(hdul, hdul2).identical
+
+    def _test_create_fitshdu(self, compression=False):
+        hdul_orig = fits.open(self.data('test0.fits'),
+                              do_not_scale_image_data=True)
+
+        fitshdu = fits.FitsHDU.fromhdulist(hdul_orig, compress=compression)
+        # Just to be meta, let's append to the same hdulist that the fitshdu
+        # encapuslates
+        hdul_orig.append(fitshdu)
+        hdul_orig.writeto(self.temp('tmp.fits'), overwrite=True)
+        del hdul_orig[-1]
+
+        hdul = fits.open(self.temp('tmp.fits'))
+        assert isinstance(hdul[-1], fits.FitsHDU)
+
+        wrapped = hdul[-1].hdulist
+        assert isinstance(wrapped, fits.HDUList)
+
+        assert hdul_orig.info(output=False) == wrapped.info(output=False)
+        assert (hdul[1].data == wrapped[1].data).all()
+        assert (hdul[2].data == wrapped[2].data).all()
+        assert (hdul[3].data == wrapped[3].data).all()
+        assert (hdul[4].data == wrapped[4].data).all()
+
+        hdul_orig.close()
+        hdul.close()

testbed/astropy__astropy/astropy/io/fits/tests/test_structured.py

@@ -0,0 +1,101 @@
+# Licensed under a 3-clause BSD style license - see PYFITS.rst
+
+import sys
+
+import numpy as np
+
+from astropy.io import fits
+from . import FitsTestCase
+
+
+def compare_arrays(arr1in, arr2in, verbose=False):
+    """
+    Compare the values field-by-field in two sets of numpy arrays or
+    recarrays.
+    """
+
+    arr1 = arr1in.view(np.ndarray)
+    arr2 = arr2in.view(np.ndarray)
+
+    nfail = 0
+    for n2 in arr2.dtype.names:
+        n1 = n2
+        if n1 not in arr1.dtype.names:
+            n1 = n1.lower()
+            if n1 not in arr1.dtype.names:
+                n1 = n1.upper()
+                if n1 not in arr1.dtype.names:
+                    raise ValueError('field name {} not found in array 1'.format(n2))
+
+        if verbose:
+            sys.stdout.write("    testing field: '{}'\n".format(n2))
+            sys.stdout.write('        shape...........')
+        if arr2[n2].shape != arr1[n1].shape:
+            nfail += 1
+            if verbose:
+                sys.stdout.write('shapes differ\n')
+        else:
+            if verbose:
+                sys.stdout.write('OK\n')
+                sys.stdout.write('        elements........')
+            w, = np.where(arr1[n1].ravel() != arr2[n2].ravel())
+            if w.size > 0:
+                nfail += 1
+                if verbose:
+                    sys.stdout.write(
+                        '\n        {} elements in field {} differ\n'.format(
+                            w.size, n2))
+            else:
+                if verbose:
+                    sys.stdout.write('OK\n')
+
+    if nfail == 0:
+        if verbose:
+            sys.stdout.write('All tests passed\n')
+        return True
+    else:
+        if verbose:
+            sys.stdout.write('{} differences found\n'.format(nfail))
+        return False
+
+
+def get_test_data(verbose=False):
+    st = np.zeros(3, [('f1', 'i4'), ('f2', 'S6'), ('f3', '>2f8')])
+
+    np.random.seed(35)
+    st['f1'] = [1, 3, 5]
+    st['f2'] = ['hello', 'world', 'byebye']
+    st['f3'] = np.random.random(st['f3'].shape)
+
+    return st
+
+
+class TestStructured(FitsTestCase):
+    def test_structured(self):
+        fname = self.data('stddata.fits')
+
+        data1, h1 = fits.getdata(fname, ext=1, header=True)
+        data2, h2 = fits.getdata(fname, ext=2, header=True)
+
+        st = get_test_data()
+
+        outfile = self.temp('test.fits')
+        fits.writeto(outfile, data1, overwrite=True)
+        fits.append(outfile, data2)
+
+        fits.append(outfile, st)
+        assert st.dtype.isnative
+        assert np.all(st['f1'] == [1, 3, 5])
+
+        data1check, h1check = fits.getdata(outfile, ext=1, header=True)
+        data2check, h2check = fits.getdata(outfile, ext=2, header=True)
+        stcheck, sthcheck = fits.getdata(outfile, ext=3, header=True)
+
+        assert compare_arrays(data1, data1check, verbose=True)
+        assert compare_arrays(data2, data2check, verbose=True)
+        assert compare_arrays(st, stcheck, verbose=True)
+
+        # try reading with view
+        dataviewcheck, hviewcheck = fits.getdata(outfile, ext=2, header=True,
+                                                 view=np.ndarray)
+        assert compare_arrays(data2, dataviewcheck, verbose=True)