dkist-processing-common 12.0.0rc5__py3-none-any.whl → 12.2.0__py3-none-any.whl

dkist_processing_common/tasks/write_extra.py

@@ -0,0 +1,333 @@
+"""Classes to support the generation of dataset extras."""
+
+import uuid
+from abc import ABC
+from abc import abstractmethod
+from datetime import datetime
+
+import numpy as np
+from astropy.io import fits
+from astropy.time import Time
+from dkist_fits_specifications.utils.formatter import reformat_dataset_extra_header
+from dkist_header_validator.spec_validators import spec_extras_validator
+
+from dkist_processing_common.codecs.fits import fits_hdulist_encoder
+from dkist_processing_common.models.extras import DatasetExtraHeaderSection
+from dkist_processing_common.models.extras import DatasetExtraType
+from dkist_processing_common.models.tags import Tag
+from dkist_processing_common.models.task_name import TaskName
+from dkist_processing_common.tasks.write_l1_base import WriteL1Base
+
+
+class WriteL1DatasetExtras(WriteL1Base, ABC):
+    """Class supporting the construction of dataset extras."""
+
+    def dataset_extra_headers(
+        self,
+        filename: str,
+        task_type: TaskName,
+        extra_name: DatasetExtraType,
+        end_time: str,
+        total_exposure: float | None = None,
+        readout_exposure: float | None = None,
+    ) -> dict:
+        """Provide common FITS header keys for dataset extras."""
+        # Build task specific header values
+        match task_type:
+            case TaskName.dark:
+                task_specific_observing_program_execution_id = (
+                    self.constants.dark_observing_program_execution_ids
+                )
+                task_specific_date_begin = self.constants.dark_date_begin
+                task_specific_raw_frames_per_fpa = (
+                    0  # can be updated in construction of dataset extra if required
+                )
+                task_specific_telescope_tracking_mode = (
+                    "None"  # can be updated in construction of dataset extra if required
+                )
+                task_specific_coude_table_tracking_mode = (
+                    "None"  # can be updated in construction of dataset extra if required
+                )
+                task_specific_telescope_scanning_mode = (
+                    "None"  # can be updated in construction of dataset extra if required
+                )
+                task_specific_average_light_level = self.constants.dark_average_light_level
+                task_specific_average_telescope_elevation = (
+                    self.constants.dark_average_telescope_elevation
+                )
+                task_specific_average_coude_table_angle = (
+                    self.constants.dark_average_coude_table_angle
+                )
+                task_specific_average_telescope_azimuth = (
+                    self.constants.dark_average_telescope_azimuth
+                )
+                task_specific_gos_level3_status = self.constants.dark_gos_level3_status
+                task_specific_gos_level3_lamp_status = self.constants.dark_gos_level3_lamp_status
+                task_specific_gos_polarizer_status = self.constants.dark_gos_polarizer_status
+                task_specific_gos_polarizer_angle = self.constants.dark_gos_polarizer_angle
+                task_specific_gos_retarder_status = self.constants.dark_gos_retarder_status
+                task_specific_gos_retarder_angle = self.constants.dark_gos_retarder_angle
+                task_specific_gos_level0_status = self.constants.dark_gos_level0_status
+            case TaskName.solar_gain:
+                task_specific_observing_program_execution_id = (
+                    self.constants.solar_gain_observing_program_execution_ids
+                )
+
+                task_specific_date_begin = self.constants.solar_gain_date_begin
+                task_specific_raw_frames_per_fpa = self.constants.solar_gain_num_raw_frames_per_fpa
+                task_specific_telescope_tracking_mode = (
+                    self.constants.solar_gain_telescope_tracking_mode
+                )
+                task_specific_coude_table_tracking_mode = (
+                    self.constants.solar_gain_coude_table_tracking_mode
+                )
+                task_specific_telescope_scanning_mode = (
+                    self.constants.solar_gain_telescope_scanning_mode
+                )
+                task_specific_average_light_level = self.constants.solar_gain_average_light_level
+                task_specific_average_telescope_elevation = (
+                    self.constants.solar_gain_average_telescope_elevation
+                )
+                task_specific_average_coude_table_angle = (
+                    self.constants.solar_gain_average_coude_table_angle
+                )
+                task_specific_average_telescope_azimuth = (
+                    self.constants.solar_gain_average_telescope_azimuth
+                )
+                task_specific_gos_level3_status = self.constants.solar_gain_gos_level3_status
+                task_specific_gos_level3_lamp_status = (
+                    self.constants.solar_gain_gos_level3_lamp_status
+                )
+                task_specific_gos_polarizer_status = self.constants.solar_gain_gos_polarizer_status
+                task_specific_gos_polarizer_angle = self.constants.solar_gain_gos_polarizer_angle
+                task_specific_gos_retarder_status = self.constants.solar_gain_gos_retarder_status
+                task_specific_gos_retarder_angle = self.constants.solar_gain_gos_retarder_angle
+                task_specific_gos_level0_status = self.constants.solar_gain_gos_level0_status
+            case TaskName.polcal:
+                task_specific_observing_program_execution_id = (
+                    self.constants.polcal_observing_program_execution_ids
+                )
+
+                task_specific_date_begin = self.constants.polcal_date_begin
+                task_specific_raw_frames_per_fpa = self.constants.polcal_num_raw_frames_per_fpa
+                task_specific_telescope_tracking_mode = (
+                    self.constants.polcal_telescope_tracking_mode
+                )
+                task_specific_coude_table_tracking_mode = (
+                    self.constants.polcal_coude_table_tracking_mode
+                )
+                task_specific_telescope_scanning_mode = (
+                    self.constants.polcal_telescope_scanning_mode
+                )
+                task_specific_average_light_level = self.constants.polcal_average_light_level
+                task_specific_average_telescope_elevation = (
+                    self.constants.polcal_average_telescope_elevation
+                )
+                task_specific_average_coude_table_angle = (
+                    self.constants.polcal_average_coude_table_angle
+                )
+                task_specific_average_telescope_azimuth = (
+                    self.constants.polcal_average_telescope_azimuth
+                )
+                task_specific_gos_level3_status = None
+                task_specific_gos_level3_lamp_status = None
+                task_specific_gos_polarizer_status = None
+                task_specific_gos_polarizer_angle = None
+                task_specific_gos_retarder_status = None
+                task_specific_gos_retarder_angle = None
+                task_specific_gos_level0_status = None
+            case _:
+                raise ValueError(f"Unsupported task type {task_type}")
+
+        start_datetime = datetime.fromisoformat(task_specific_date_begin)
+        end_datetime = datetime.fromisoformat(end_time)
+
+        dataset_extra_header = {
+            DatasetExtraHeaderSection.common: {
+                "BUNIT": "count",
+                "DATE": Time.now().fits,
+                "DATE-BEG": task_specific_date_begin,
+                "DATE-END": end_time,
+                "TELAPSE": (end_datetime - start_datetime).total_seconds(),
+                "DATE-AVG": (start_datetime + (end_datetime - start_datetime) / 2).isoformat(),
+                "TIMESYS": "UTC",
+                "ORIGIN": "National Solar Observatory",
+                "TELESCOP": "Daniel K. Inouye Solar Telescope",
+                "OBSRVTRY": "Haleakala High Altitude Observatory Site",
+                "NETWORK": "NSF-DKIST",
+                "INSTRUME": self.constants.instrument,
+                "OBJECT": "unknown",
+                "CAM_ID": self.constants.camera_id,
+                "CAMERA": self.constants.camera_name,
+                "BITDEPTH": self.constants.camera_bit_depth,
+                "XPOSURE": total_exposure,
+                "TEXPOSUR": readout_exposure,
+                "HWBIN1": self.constants.hardware_binning_x,
+                "HWBIN2": self.constants.hardware_binning_y,
+                "SWBIN1": self.constants.software_binning_x,
+                "SWBIN2": self.constants.software_binning_y,
+                "NSUMEXP": task_specific_raw_frames_per_fpa,
+                "DSETID": self.constants.dataset_id,
+                "PROCTYPE": "L1_EXTRA",
+                "RRUNID": self.recipe_run_id,
+                "RECIPEID": self.metadata_store_recipe_run.recipeInstance.recipeId,
+                "RINSTID": self.metadata_store_recipe_run.recipeInstanceId,
+                "FILENAME": filename,
+                "HEAD_URL": "",
+                "INFO_URL": self.docs_base_url,
+                "CAL_URL": "",
+                "CALVERS": self.version_from_module_name(),
+                "IDSPARID": (
+                    parameters.inputDatasetPartId
+                    if (parameters := self.metadata_store_input_dataset_parameters)
+                    else None
+                ),
+                "IDSOBSID": (
+                    observe_frames.inputDatasetPartId
+                    if (observe_frames := self.metadata_store_input_dataset_observe_frames)
+                    else None
+                ),
+                "IDSCALID": (
+                    calibration_frames.inputDatasetPartId
+                    if (calibration_frames := self.metadata_store_input_dataset_calibration_frames)
+                    else None
+                ),
+                "WKFLVERS": self.workflow_version,
+                "WKFLNAME": self.workflow_name,
+                "MANPROCD": self.workflow_had_manual_intervention,
+                "FILE_ID": uuid.uuid4().hex,
+                "OBSPR_ID": task_specific_observing_program_execution_id[
+                    0
+                ],  # The OP IDs are stored sorted by number of appearances of each OP ID in the source task type frames
+                "EXTOBSID": ",".join(task_specific_observing_program_execution_id[1:]),
+                "EXPER_ID": self.constants.experiment_id,
+                "PROP_ID": self.constants.proposal_id,
+                "HLSVERS": self.constants.hls_version,
+                "LINEWAV": self.constants.wavelength,
+                "TELTRACK": (
+                    task_specific_telescope_tracking_mode if task_type != TaskName.dark else None
+                ),
+                "TTBLTRCK": (
+                    task_specific_coude_table_tracking_mode if task_type != TaskName.dark else None
+                ),
+                "TELSCAN": (
+                    task_specific_telescope_scanning_mode if task_type != TaskName.dark else None
+                ),
+                "EXTNAME": extra_name,
+            },
+            DatasetExtraHeaderSection.aggregate: {
+                "AVGLLVL": task_specific_average_light_level,
+                "ATELEVAT": task_specific_average_telescope_elevation,
+                "ATTBLANG": task_specific_average_coude_table_angle,
+                "ATAZIMUT": task_specific_average_telescope_azimuth,
+            },
+            DatasetExtraHeaderSection.iptask: {
+                "IPTASK": "GAIN" if "GAIN" in task_type else task_type,
+            },
+            DatasetExtraHeaderSection.gos: {
+                "LVL3STAT": task_specific_gos_level3_status,
+                "LAMPSTAT": task_specific_gos_level3_lamp_status,
+                "LVL2STAT": task_specific_gos_polarizer_status,
+                "POLANGLE": task_specific_gos_polarizer_angle,
+                "LVL1STAT": task_specific_gos_retarder_status,
+                "RETANGLE": task_specific_gos_retarder_angle,
+                "LVL0STAT": task_specific_gos_level0_status,
+            },
+        }
+
+        # Remove specific headers from dark frames as they don't constants to fill them
+        if task_type == TaskName.dark:
+            for key in ["TELTRACK", "TTBLTRCK", "TELSCAN"]:
+                del dataset_extra_header[DatasetExtraHeaderSection.common][key]
+
+        # Remove specific headers from polcal frames as they don't have constants to fill them
+        if task_type == TaskName.polcal:
+            for key in [
+                "LVL3STAT",
+                "LAMPSTAT",
+                "LVL2STAT",
+                "POLANGLE",
+                "LVL1STAT",
+                "RETANGLE",
+                "LVL0STAT",
+            ]:
+                del dataset_extra_header[DatasetExtraHeaderSection.gos][key]
+
+        return dataset_extra_header
+
+    def build_dataset_extra_header(
+        self,
+        sections: list[DatasetExtraHeaderSection],
+        filename: str,
+        task_type: TaskName,
+        extra_name: DatasetExtraType,
+        total_exposure: float | None = None,
+        readout_exposure: float | None = None,
+        end_time: str | None = None,
+    ) -> fits.Header:
+        """Build FITS header for dataset extra file."""
+        header = fits.Header()
+        all_section_headers = self.dataset_extra_headers(
+            filename=filename,
+            task_type=task_type,
+            total_exposure=total_exposure,
+            readout_exposure=readout_exposure,
+            extra_name=extra_name,
+            end_time=end_time,
+        )
+        for section in sections:
+            header.update(all_section_headers[section].items())
+        return header
+
+    def format_extra_filename(self, extra_name: DatasetExtraType | str, detail: str | None = None):
+        """Format the filename of dataset extras for consistency."""
+        base_filename = f"{self.constants.instrument}_{self.constants.dataset_id}_{extra_name.replace(' ', '-')}"
+        if detail:
+            base_filename += "_" + detail
+        filename_counter = str(self.filename_counter.increment(base_filename))
+        return f"{base_filename}_{filename_counter}.fits"
+
+    def assemble_and_write_dataset_extra(
+        self,
+        data: np.ndarray | list[np.ndarray],
+        header: fits.Header | list[fits.Header],
+        filename: str,
+    ):
+        """Given the data and header information, write the dataset extra."""
+        if isinstance(data, list) and isinstance(header, list):
+            if len(data) != len(header):
+                raise ValueError(
+                    f"{len(data)} data arrays were provided with {len(header)} headers. These must be equal."
+                )
+        if isinstance(data, np.ndarray):
+            data = [data]
+        if isinstance(header, fits.Header):
+            header = [header]
+        hdus = [fits.PrimaryHDU()]  # The first HDU in the list is an empty PrimaryHDU
+        for i, data_array in enumerate(data):
+            tile_size = self.compute_tile_size_for_array(data_array)
+            hdu = fits.CompImageHDU(header=header[i], data=data_array, tile_shape=tile_size)
+            formatted_header = reformat_dataset_extra_header(hdu.header)
+            hdu = fits.CompImageHDU(header=formatted_header, data=hdu.data, tile_shape=tile_size)
+            hdus.append(hdu)
+        self.write(
+            data=fits.HDUList(hdus),
+            tags=[Tag.extra(), Tag.output()],
+            encoder=fits_hdulist_encoder,
+            relative_path=filename,
+        )
+        self.update_framevol(relative_path=filename)
+
+        # Check that the written file passes spec 214 validation if requested
+        if self.validate_l1_on_write:
+            spec_extras_validator.validate(self.scratch.absolute_path(filename), extra=False)
+
+    @abstractmethod
+    def run(self) -> None:
+        """
+        For each dataset extra.
+
+        * Gather the source data in whatever manner is necessary
+        * Build a header using the `build_dataset_extra_header` method to help with header construction
+        * Write the dataset extra using `assemble_and_write_dataset_extra()`
+        """

dkist_processing_common/tasks/write_l1.py

@@ -1,11 +1,9 @@
 """Task(s) for writing level 1 data as 214 compliant fits files."""
 
-import importlib
 import logging
 import uuid
 from abc import ABC
 from abc import abstractmethod
-from functools import cached_property
 from pathlib import Path
 from string import ascii_uppercase
 from typing import Literal
@@ -34,7 +32,7 @@ from dkist_processing_common.models.fried_parameter import r0_valid
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.models.wavelength import WavelengthRange
 from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
-from dkist_processing_common.tasks import WorkflowTaskBase
+from dkist_processing_common.tasks.write_l1_base import WriteL1Base
 
 logger = logging.getLogger(__name__)
 
@@ -43,7 +41,7 @@ __all__ = ["WriteL1Frame"]
 from dkist_processing_common.tasks.mixin.metadata_store import MetadataStoreMixin
 
 
-class WriteL1Frame(WorkflowTaskBase, MetadataStoreMixin, ABC):
+class WriteL1Frame(WriteL1Base, ABC):
     """
     Task to convert final calibrated science frames into spec 214 compliant level 1 frames.
 
@@ -108,45 +106,6 @@ class WriteL1Frame(WorkflowTaskBase, MetadataStoreMixin, ABC):
                         self.scratch.absolute_path(relative_path), extra=False
                     )
 
-    @cached_property
-    def tile_size_param(self) -> int | None:
-        """Get the tile size parameter for compression."""
-        return self.metadata_store_recipe_run.configuration.tile_size
-
-    @cached_property
-    def validate_l1_on_write(self) -> bool:
-        """Check for validate on write."""
-        return self.metadata_store_recipe_run.configuration.validate_l1_on_write
-
-    @cached_property
-    def workflow_had_manual_intervention(self):
-        """Indicate determining if any provenance capturing steps had manual intervention."""
-        for provenance_record in self.metadata_store_recipe_run.recipeRunProvenances:
-            if provenance_record.isTaskManual:
-                return True
-        return False
-
-    def compute_tile_size_for_array(self, data: np.ndarray) -> list | None:
-        """Determine the tile size to use for compression accounting for array shape minimums."""
-        if self.tile_size_param is None:
-            return None
-        tile_size = []
-        for dim_size in data.shape:
-            if dim_size < self.tile_size_param:
-                tile_size.append(dim_size)
-            else:
-                tile_size.append(self.tile_size_param)
-        return tile_size
-
-    def update_framevol(self, relative_path: str) -> None:
-        """Update FRAMEVOL key to be exactly the size of the file on-disk."""
-        full_path = self.scratch.workflow_base_path / relative_path
-        compressed_size = full_path.stat().st_size / 1024 / 1024
-        hdul = fits.open(full_path, mode="update")
-        hdul[1].header["FRAMEVOL"] = compressed_size
-        hdul.flush()
-        del hdul
-
     def replace_header_values(self, header: fits.Header, data: np.ndarray) -> fits.Header:
         """Replace header values that should already exist with new values."""
         header["FILE_ID"] = uuid.uuid4().hex
@@ -430,18 +389,6 @@ class WriteL1Frame(WorkflowTaskBase, MetadataStoreMixin, ABC):
         )
         return header
 
-    def version_from_module_name(self) -> str:
-        """
-        Get the value of __version__ from a module given its name.
-
-        Returns
-        -------
-        The value of __version__
-        """
-        package = self.__module__.split(".")[0]
-        module = importlib.import_module(package)
-        return module.__version__
-
     @abstractmethod
     def add_dataset_headers(
         self, header: fits.Header, stokes: Literal["I", "Q", "U", "V"]

dkist_processing_common/tasks/write_l1_base.py

@@ -0,0 +1,67 @@
+"""Base class for writing L1 FITS products with headers."""
+
+import importlib
+from abc import ABC
+from functools import cached_property
+
+import numpy as np
+from astropy.io import fits
+
+from dkist_processing_common.tasks import WorkflowTaskBase
+from dkist_processing_common.tasks.mixin.metadata_store import MetadataStoreMixin
+
+
+class WriteL1Base(WorkflowTaskBase, MetadataStoreMixin, ABC):
+    """Base class for writing L1 FITS products with headers."""
+
+    def version_from_module_name(self) -> str:
+        """
+        Get the value of __version__ from a module given its name.
+
+        Returns
+        -------
+        The value of __version__
+        """
+        package = self.__module__.split(".")[0]
+        module = importlib.import_module(package)
+        return module.__version__
+
+    @cached_property
+    def workflow_had_manual_intervention(self) -> bool:
+        """Indicate determining if any provenance capturing steps had manual intervention."""
+        for provenance_record in self.metadata_store_recipe_run.recipeRunProvenances:
+            if provenance_record.isTaskManual:
+                return True
+        return False
+
+    def update_framevol(self, relative_path: str) -> None:
+        """Update FRAMEVOL key to be exactly the size of the file on-disk."""
+        full_path = self.scratch.workflow_base_path / relative_path
+        compressed_size = full_path.stat().st_size / 1024 / 1024
+        hdul = fits.open(full_path, mode="update")
+        for i in range(1, len(hdul)):
+            hdul[i].header["FRAMEVOL"] = compressed_size
+        hdul.flush()
+        del hdul
+
+    @cached_property
+    def tile_size_param(self) -> int | None:
+        """Get the tile size parameter for compression."""
+        return self.metadata_store_recipe_run.configuration.tile_size
+
+    def compute_tile_size_for_array(self, data: np.ndarray) -> list | None:
+        """Determine the tile size to use for compression accounting for array shape minimums."""
+        if self.tile_size_param is None:
+            return None
+        tile_size = []
+        for dim_size in data.shape:
+            if dim_size < self.tile_size_param:
+                tile_size.append(dim_size)
+            else:
+                tile_size.append(self.tile_size_param)
+        return tile_size
+
+    @cached_property
+    def validate_l1_on_write(self) -> bool:
+        """Check for validate on write."""
+        return self.metadata_store_recipe_run.configuration.validate_l1_on_write

dkist_processing_common/tests/test_codecs.py

@@ -183,7 +183,7 @@ def primary_hdu_list(ndarray_object, fits_header) -> HDUList:
 
 @pytest.fixture
 def path_to_primary_fits_file(primary_hdu_list, tmp_file) -> Path:
-    primary_hdu_list.writeto(tmp_file)
+    primary_hdu_list.writeto(tmp_file, checksum=True)
     return tmp_file
 
 
@@ -210,7 +210,7 @@ def compressed_hdu_list(ndarray_object, fits_header) -> HDUList:
 
 @pytest.fixture
 def path_to_compressed_fits_file(compressed_hdu_list, tmp_file) -> Path:
-    compressed_hdu_list.writeto(tmp_file)
+    compressed_hdu_list.writeto(tmp_file, checksum=True)
     return tmp_file
 
 
@@ -472,16 +472,27 @@ def test_bytesio_decoder(bytesIO_object, path_to_bytesIO):
         pytest.param("path_to_compressed_fits_file", id="compressed"),
     ],
 )
-def test_fits_hdu_decoder(path_fixture_name, ndarray_object, fits_header, request):
+@pytest.mark.parametrize(
+    "checksum", [pytest.param(True, id="checksum"), pytest.param(False, id="no_checksum")]
+)
+@pytest.mark.parametrize(
+    "decompress", [pytest.param(True, id="decompress"), pytest.param(False, id="no_decompress")]
+)
+def test_fits_hdu_decoder(
+    path_fixture_name, ndarray_object, fits_header, request, checksum, decompress
+):
     """
     Given: Path to a FITS file
     When: Decoding the path with the fits_hdu_decoder
     Then: The correct data are returned
     """
     file_path = request.getfixturevalue(path_fixture_name)
-    hdu = fits_hdu_decoder(file_path)
+    hdu = fits_hdu_decoder(file_path, checksum=checksum, disable_image_compression=not decompress)
 
-    assert np.array_equal(hdu.data, ndarray_object)
+    if "compressed" in path_fixture_name and not decompress:
+        assert not np.array_equal(hdu.data, ndarray_object)
+    else:
+        assert np.array_equal(hdu.data, ndarray_object)
     assert hdu.header["foo"] == fits_header["foo"]
 
 
@@ -492,7 +503,15 @@ def test_fits_hdu_decoder(path_fixture_name, ndarray_object, fits_header, reques
         pytest.param("path_to_compressed_fits_file", id="compressed"),
     ],
 )
-def test_fits_access_decoder(path_fixture_name, ndarray_object, fits_header, request):
+@pytest.mark.parametrize(
+    "checksum", [pytest.param(True, id="checksum"), pytest.param(False, id="no_checksum")]
+)
+@pytest.mark.parametrize(
+    "decompress", [pytest.param(True, id="decompress"), pytest.param(False, id="no_decompress")]
+)
+def test_fits_access_decoder(
+    path_fixture_name, ndarray_object, fits_header, request, checksum, decompress
+):
     """
     Given: Path to a FITS file
     When: Decoding the path with the fits_access_decoder
@@ -500,20 +519,47 @@ def test_fits_access_decoder(path_fixture_name, ndarray_object, fits_header, req
     """
     file_path = request.getfixturevalue(path_fixture_name)
 
-    fits_obj = fits_access_decoder(file_path, fits_access_class=DummyFitsAccess)
+    fits_obj = fits_access_decoder(
+        file_path,
+        fits_access_class=DummyFitsAccess,
+        checksum=checksum,
+        disable_image_compression=not decompress,
+    )
     assert fits_obj.name == str(file_path)
-    assert np.array_equal(fits_obj.data, ndarray_object)
     assert fits_obj.foo == fits_header["foo"]
+    if "compressed" in path_fixture_name and not decompress:
+        assert not np.array_equal(fits_obj.data, ndarray_object)
+    else:
+        assert np.array_equal(fits_obj.data, ndarray_object)
 
 
-def test_fits_array_decoder(path_to_primary_fits_file, ndarray_object):
+@pytest.mark.parametrize(
+    "path_fixture_name",
+    [
+        pytest.param("path_to_primary_fits_file", id="uncompressed"),
+        pytest.param("path_to_compressed_fits_file", id="compressed"),
+    ],
+)
+@pytest.mark.parametrize(
+    "checksum", [pytest.param(True, id="checksum"), pytest.param(False, id="no_checksum")]
+)
+@pytest.mark.parametrize(
+    "decompress", [pytest.param(True, id="decompress"), pytest.param(False, id="no_decompress")]
+)
+def test_fits_array_decoder(path_fixture_name, ndarray_object, request, checksum, decompress):
     """
     Given: Path to a FITS file
     When: Decoding the path the fits_array_decoder
     Then: The correct data are returned
     """
-    array = fits_array_decoder(path_to_primary_fits_file)
-    assert np.array_equal(ndarray_object, array)
+    file_path = request.getfixturevalue(path_fixture_name)
+    array = fits_array_decoder(
+        file_path, checksum=checksum, disable_image_compression=not decompress
+    )
+    if "compressed" in path_fixture_name and not decompress:
+        assert not np.array_equal(array, ndarray_object)
+    else:
+        assert np.array_equal(ndarray_object, array)
 
 
 def test_fits_array_decoder_autosqueeze(