This is one last fix which is again also arguably a bug fix which I'd like to include in 8.0.1 to fix some of the behavior with the new logical NULL functionality introduced in 8.0.0.

Reading a FITS logical column without logical_as_bytes=True returns a bool array in which NULL (b'\x00') is coerced to False, and warns that it has done so. But on write-back the original NULL bytes are currently preserved rather than converted, so the bool array users read and edit does not round-trip to disk: explicitly assigning False to a row that was NULL is silently dropped, and the column keeps emitting the contains NULL warning on every read even after every value has been set. In other words the warning is not correctly reflecting the truth.

Here is a minimal example to demonstrate the bug:

>>> import numpy as np
>>> from astropy.io import fits

>>> # build a file whose logical column has a NULL in row 1 (raw bytes b'T', b'\x00', b'F')
>>> col = fits.Column("flag", "L", array=np.array([b"T", b"\x00", b"F"], dtype="S1"))
>>> fits.BinTableHDU.from_columns([col]).writeto("flags.fits", overwrite=True)

>>> hdul = fits.open("flags.fits")
>>> flag = hdul[1].data["flag"]          # materialize the column as a bool array
WARNING: Column 'flag' contains NULL (undefined) values which will be converted to False. To preserve NULL information, reopen the file with logical_as_bytes=True and check for bytes values of b'\x00' (NULL), b'T' (True), and b'F' (False). [astropy.io.fits.fitsrec]
>>> flag
array([ True, False, False])
>>> flag[0] = False                      # row 0 was True  -> changes to b'F'
>>> flag[1] = False                      # row 1 was NULL  -> *should* change to b'F'
>>> flag[2] = True                       # row 2 was False -> changes to b'T'
>>> hdul.writeto("out.fits", overwrite=True)
>>> hdul.close()

>>> # before this PR: rows 0 and 2 changed, but row 1 is still NULL
>>> fits.open("out.fits", logical_as_bytes=True)[1].data["flag"].tobytes()
b'F\x00T'

The issue here is that _scale_back decides which raw bytes to rewrite with raw_field == ord("T"), which is False for both a NULL byte and a b'F' byte. The cached False therefore "matches" the NULL byte and the byte is left untouched. The selective write was added with the 8.0 NULL support to preserve genuine NULLs, but it cannot distinguish an explicit False from a False produced by coercing a NULL.

The cleanest way I've found to fix it is that once a NULL-containing logical column has been materialized as a bool array (the lossy view the warning is about), write it back as b'T'/b'F'. With this PR the same edit gives:

>>> hdul = fits.open("flags.fits")
>>> hdul[1].data["flag"][1] = False
WARNING: Column 'flag' contains NULL (undefined) values which will be converted to False. ... [astropy.io.fits.fitsrec]
>>> hdul.writeto("out.fits", overwrite=True)
>>> hdul.close()
>>> fits.open("out.fits", logical_as_bytes=True)[1].data["flag"].tobytes()
b'TFF'

There are two side effects of this, which I think/hope we can live with:

1. Conversion is lazy and per-column, so whether NULL survives a copy depends on whether you touched the column. If you read a file and never access the column, NULLs are preserved on disk even if you opened with logical_as_bytes=False - we have to do this because data access is lazy, so we can't go through all the data at open time and convert all the data over to bool preemptively.

2. Operations that access every column -- repr/printing the table, Table.read, iterating rows -- count as reading the logical column, so they too cause its NULLs to be written as False on a later write:

>>> hdul = fits.open("flags.fits")
>>> _ = repr(hdul[1].data)              # converts all columns
WARNING: Column 'flag' contains NULL (undefined) values which will be converted to False. ... [astropy.io.fits.fitsrec]
>>> hdul.writeto("copy2.fits", overwrite=True)
>>> hdul.close()
>>> fits.open("copy2.fits", logical_as_bytes=True)[1].data["flag"].tobytes()
b'TFF'

The same rule applies under mode='update': reading a NULL logical column and letting the file flush on close rewrites those NULLs as False in place. To read or edit NULL deliberately in any of these situations, use logical_as_bytes=True.

To be clear though, the most important here is that the warning and behavior are consistent. If a warning is emitted, then the data will be changed when the file is written (which is not the case currently). If a user opens a file in update mode just to update the header, the logical data won't be touched.

• By checking this box, the PR author has requested that maintainers do NOT use the "Squash and Merge" button. Maintainers should respect this when possible; however, the final decision is at the discretion of the maintainer that merges the PR.