dkist-processing-cryonirsp 1.4.15__py3-none-any.whl → 1.4.16rc1__py3-none-any.whl

changelog/170.feature.rst

@@ -0,0 +1,11 @@
+Remove read/write mixins for tasks: intermediate frame, linearized frame, and beam access.
+The functionality of those mixins is replaced with the standard read and write methods
+from `dkist-processing-common` and three new elements:
+
+* New composite tags for intermediate frames, linearized frames, and beam boundary data.
+* New `cryo_fits_access_decoder` and `cryo_fits_array_decoder` that replace the standard decoders
+from `dkist-processing-common`.  The new decoders optionally slice out the illuminated beam
+portion of the array and take optional `fits_access_class` arguments.
+* New `CryonirspLinearizedFitsAccess` fits access class that inherits from CryonirspL0FitsAccess
+and handles flipping the dispersion axis for the SP arm so that wavelength increases from left
+to right like the other instruments.

changelog/170.misc.1.rst

@@ -0,0 +1,2 @@
+Move the BeamBoundaries dataclass from the beam_boundaries_base task to a new beam_boundaries model module.
+The move allows BeamBoundaries to be used without circular imports.

changelog/170.misc.rst

@@ -0,0 +1,3 @@
+Use the existing BeamBoundaries dataclass and new intermediate_beam_boundaries composite tag with
+standard read methods to access beam boundaries where beam slicing is necessary. BeamBoundary objects
+are passed to new decoders to access the illuminated beam portion of the array.

changelog/174.bugfix.rst

@@ -0,0 +1 @@
+Remove the lamp gain task from CI local workflows.

dkist_processing_cryonirsp/codecs/__init__.py

@@ -0,0 +1,5 @@
+"""
+Encoders and decoders for `WorkflowTaskBase`'s `write` and `read` methods.
+
+All encoders should return `bytes` and all decoders should accept `Paths`.
+"""

dkist_processing_cryonirsp/codecs/fits.py

@@ -0,0 +1,52 @@
+"""Encoders and decoders for writing and reading Cryo-NIRSP FITS files."""
+from pathlib import Path
+
+import numpy as np
+from dkist_processing_common.codecs.fits import fits_access_decoder as common_fits_access_decoder
+from dkist_processing_common.models.fits_access import FitsAccessBase
+
+from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundary
+
+
+def cryo_fits_access_decoder(
+    path: Path,
+    fits_access_class: FitsAccessBase = FitsAccessBase,
+    beam_boundary: BeamBoundary | None = None,
+    **fits_access_kwargs,
+) -> FitsAccessBase:
+    """
+    Read a Path with `fits`, ingest into a `FitsAccessBase`-type object, then slice out the beam.
+
+    Cryo-specific replacement for method from `dkist-processing-common` with the same name.
+    """
+    frame = common_fits_access_decoder(
+        path, fits_access_class=fits_access_class, **fits_access_kwargs
+    )
+
+    if beam_boundary is not None:
+        frame.data = frame.data[beam_boundary.slices]
+
+    return frame
+
+
+def cryo_fits_array_decoder(
+    path: Path,
+    fits_access_class: FitsAccessBase = FitsAccessBase,
+    beam_boundary: BeamBoundary | None = None,
+    auto_squeeze: bool = True,
+    **fits_access_kwargs,
+) -> np.array:
+    """
+    Read a Path with `fits` and return the `.data` from `fits_access_decoder`.
+
+    Cryo-specific replacement for method from `dkist-processing-common` with the same name.
+    Unlike the version in `-common`, this method allows a fits_access_class parameter.
+    """
+    frame = cryo_fits_access_decoder(
+        path,
+        fits_access_class=fits_access_class,
+        beam_boundary=beam_boundary,
+        auto_squeeze=auto_squeeze,
+        **fits_access_kwargs,
+    )
+    return frame.data

dkist_processing_cryonirsp/models/beam_boundaries.py

@@ -0,0 +1,39 @@
+"""Beam boundary class."""
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass
+class BeamBoundary:
+    """Simple dataclass to hold boundary information for the illuminated portion of the beam array."""
+
+    y_min: int
+    y_max: int
+    x_min: int
+    x_max: int
+
+    @property
+    def y_slice(self):
+        """Return a slice object representing the illumination along the y-axis (numpy 0 axis)."""
+        return slice(self.y_min, self.y_max)
+
+    @property
+    def x_slice(self):
+        """Return a slice object representing the illumination along the x-axis (numpy 1 axis)."""
+        return slice(self.x_min, self.x_max)
+
+    @property
+    def slices(self):
+        """Return a tuple of slices in numpy order representing the illuminated portion of the beam array."""
+        return self.y_slice, self.x_slice
+
+    @property
+    def beam_boundaries(self):
+        """Return a tuple containing the beam boundaries."""
+        return self.y_min, self.y_max, self.x_min, self.x_max
+
+    @property
+    def beam_boundaries_array(self):
+        """Return a tuple containing the beam boundaries."""
+        return np.array(self.beam_boundaries)

dkist_processing_cryonirsp/models/parameters.py

@@ -7,7 +7,6 @@ import numpy as np
 from dkist_processing_common.models.parameters import ParameterArmIdMixin
 from dkist_processing_common.models.parameters import ParameterBase
 from dkist_processing_common.models.parameters import ParameterWavelengthMixin
-from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetMixin
 
 from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
 

dkist_processing_cryonirsp/models/tags.py

@@ -166,3 +166,37 @@ class CryonirspTag(Tag):
     def task_characteristic_spectra(cls) -> str:
         """Tags 1D intermediate characteristic spectra."""
         return cls.format_tag(StemName.task, CryonirspTaskName.solar_char_spec.value)
+
+    ##################
+    # COMPOSITE TAGS #
+    ##################
+    @classmethod
+    def intermediate_frame(
+        cls, beam: int | None = None, exposure_conditions: ExposureConditions | None = None
+    ) -> list[str]:
+        """Tag by intermediate and frame, and optionally by beam and exposure_conditions."""
+        tag_list = [cls.intermediate(), cls.frame()]
+        if beam is not None:
+            tag_list += [cls.beam(beam)]
+        if exposure_conditions is not None:
+            tag_list += [cls.exposure_conditions(exposure_conditions)]
+        return tag_list
+
+    @classmethod
+    def linearized_frame(
+        cls, beam: int | None = None, exposure_conditions: ExposureConditions | None = None
+    ) -> list[str]:
+        """Tag by linearized, by frame, by beam, and optionally by exposure_conditions."""
+        tag_list = [cls.linearized(), cls.frame()]
+        if beam is not None:
+            tag_list += [cls.beam(beam)]
+        if exposure_conditions is not None:
+            tag_list += [cls.exposure_conditions(exposure_conditions)]
+        return tag_list
+
+    @classmethod
+    def intermediate_beam_boundaries(cls, beam: int) -> list[str]:
+        """Tag list for retrieving beam boundaries."""
+        tag_list = cls.intermediate_frame(beam=beam)
+        tag_list += [cls.task_beam_boundaries()]
+        return tag_list

dkist_processing_cryonirsp/parsers/cryonirsp_l0_fits_access.py

@@ -1,4 +1,5 @@
 """CryoNIRSP FITS access for L0 data."""
+import numpy as np
 from astropy.io import fits
 from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
 
@@ -8,7 +9,7 @@ from dkist_processing_cryonirsp.models.exposure_conditions import ExposureCondit
 
 class CryonirspRampFitsAccess(L0FitsAccess):
     """
-    Class to provide easy access to L0 headers for non-linearized (raw) CryoNIRSP data.
+    Class to provide easy access to L0 headers for non-linearized (raw) files.
 
     i.e. instead of <CryonirspL0FitsAccess>.header['key'] this class lets us use <CryonirspL0FitsAccess>.key instead
 
@@ -46,7 +47,7 @@ class CryonirspRampFitsAccess(L0FitsAccess):
 
 class CryonirspL0FitsAccess(L0FitsAccess):
     """
-    Class to provide easy access to L0 headers for linearized (ready for processing) CryoNIRSP data.
+    Class to provide easy access to L0 headers for linearized (ready for processing) files.
 
     i.e. instead of <CryonirspL0FitsAccess>.header['key'] this class lets us use <CryonirspL0FitsAccess>.key instead
 
@@ -110,3 +111,38 @@ class CryonirspL0FitsAccess(L0FitsAccess):
     def cn1_scan_step(self):
         """Convert the inner loop step number from float to int."""
         return int(self.header["CNP1DCUR"])
+
+
+class CryonirspLinearizedFitsAccess(CryonirspL0FitsAccess):
+    """
+    Class to access to linearized CryoNIRSP data.
+
+    Flip the dispersion axis of the SP arm.
+    Cryo's wavelength decreases from left to right, so we flip it here to match the other instruments.
+
+    Parameters
+    ----------
+    hdu :
+        Fits L0 header object
+
+    name : str
+        The name of the file that was loaded into this FitsAccess object
+
+    auto_squeeze : bool
+        When set to True, dimensions of length 1 will be removed from the array
+    """
+
+    @property
+    def data(self):
+        """Override parent method to flip the SP arm array."""
+        parent_data = super().data
+        if self.arm_id == "SP":
+            return np.flip(parent_data, 1)
+        return parent_data
+
+    @data.setter
+    def data(self, value: np.array):
+        """Override parent setter method to unflip the SP arm array."""
+        if self.arm_id == "SP":
+            value = np.flip(value, 1)
+        super(CryonirspL0FitsAccess, type(self)).data.__set__(self, value)

dkist_processing_cryonirsp/tasks/assemble_movie.py

@@ -1,11 +1,11 @@
 """CryoNIRSP-specific assemble movie task subclass."""
 import numpy as np
-from dkist_processing_common.codecs.fits import fits_array_decoder
 from dkist_processing_common.tasks import AssembleMovie
 from dkist_service_configuration.logging import logger
 from PIL import ImageDraw
 from PIL.ImageFont import FreeTypeFont
 
+from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
 from dkist_processing_cryonirsp.models.constants import CryonirspConstants
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
@@ -36,7 +36,7 @@ class AssembleCryonirspMovieBase(AssembleMovie):
     def compute_frame_shape(self) -> tuple[int, int]:
         """Dynamically set the dimensions of the movie based on L1 file shape."""
         movie_frame_arrays = self.read(
-            tags=[CryonirspTag.movie_frame()], decoder=fits_array_decoder
+            tags=[CryonirspTag.movie_frame()], decoder=cryo_fits_array_decoder
         )
         random_frame = next(movie_frame_arrays)
         raw_L1_shape = random_frame.shape

dkist_processing_cryonirsp/tasks/bad_pixel_map.py

@@ -1,11 +1,15 @@
 """Task class for bad pixel map computation."""
 import numpy as np
 import scipy.ndimage as spnd
+from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_math.statistics import average_numpy_arrays
 from dkist_service_configuration.logging import logger
 
+from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
-from dkist_processing_cryonirsp.models.task_name import CryonirspTaskName
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import (
+    CryonirspLinearizedFitsAccess,
+)
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
 
 __all__ = ["BadPixelMapCalibration"]
@@ -68,8 +72,10 @@ class BadPixelMapCalibration(CryonirspTaskBase):
                 bad_pixel_map[zeros] = 1
 
         with self.apm_writing_step("Writing bad pixel map"):
-            self.intermediate_frame_write_arrays(
-                bad_pixel_map, task=CryonirspTaskName.bad_pixel_map.value
+            self.write(
+                data=bad_pixel_map,
+                tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],
+                encoder=fits_array_encoder,
             )
 
     def compute_average_gain_array(self) -> np.ndarray:
@@ -85,12 +91,11 @@ class BadPixelMapCalibration(CryonirspTaskBase):
         -------
         The average gain array
         """
-        lin_corr_gain_arrays = self.linearized_frame_full_array_generator(
-            tags=[
-                CryonirspTag.task_solar_gain(),
-                CryonirspTag.linearized(),
-                CryonirspTag.frame(),
-            ]
+        lin_corr_gain_arrays = self.read(
+            tags=[CryonirspTag.linearized_frame(), CryonirspTag.task_solar_gain()],
+            decoder=cryo_fits_array_decoder,
+            fits_access_class=CryonirspLinearizedFitsAccess,
         )
+
         averaged_gain_data = average_numpy_arrays(lin_corr_gain_arrays)
         return averaged_gain_data

dkist_processing_cryonirsp/tasks/beam_boundaries_base.py

@@ -1,8 +1,8 @@
 """CryoNIRSP compute beam boundary task."""
 from abc import abstractmethod
-from dataclasses import dataclass
 
 import numpy as np
+from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_math.statistics import average_numpy_arrays
 from dkist_service_configuration.logging import logger
 from largestinteriorrectangle import lir
@@ -11,40 +11,15 @@ from skimage.exposure import rescale_intensity
 from skimage.morphology import disk
 from skimage.util import img_as_ubyte
 
+from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
+from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundary
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import (
+    CryonirspLinearizedFitsAccess,
+)
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
 
-__all__ = ["BeamBoundariesCalibrationBase", "BeamBoundary"]
-
-
-@dataclass
-class BeamBoundary:
-    """Simple dataclass to hold boundary information for the illuminated portion of the beam array."""
-
-    y_min: int
-    y_max: int
-    x_min: int
-    x_max: int
-
-    @property
-    def y_slice(self):
-        """Return a slice object representing the illumination along the y-axis (numpy 0 axis)."""
-        return slice(self.y_min, self.y_max)
-
-    @property
-    def x_slice(self):
-        """Return a slice object representing the illumination along the x-axis (numpy 1 axis)."""
-        return slice(self.x_min, self.x_max)
-
-    @property
-    def beam_boundaries(self):
-        """Return a tuple containing the beam boundaries."""
-        return self.y_min, self.y_max, self.x_min, self.x_max
-
-    @property
-    def beam_boundaries_array(self):
-        """Return a tuple containing the beam boundaries."""
-        return np.array(self.beam_boundaries)
+__all__ = ["BeamBoundariesCalibrationBase"]
 
 
 class BeamBoundariesCalibrationBase(CryonirspTaskBase):
@@ -91,7 +66,12 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
 
         # Step 2:
         with self.apm_task_step(f"Retrieve bad pixel map"):
-            bad_pixel_map = self.intermediate_frame_load_full_bad_pixel_map()
+            bad_pixel_map = next(
+                self.read(
+                    tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],
+                    decoder=cryo_fits_array_decoder,
+                )
+            )
             corrected_solar_gain_array = self.corrections_correct_bad_pixels(
                 average_solar_gain_array, bad_pixel_map
             )
@@ -128,10 +108,13 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
         # Step 10:
         with self.apm_writing_step("Writing beam boundaries"):
             for beam, bounds in enumerate(boundaries, start=1):
-                self.intermediate_frame_write_arrays(
-                    bounds.beam_boundaries_array,
-                    task_tag=CryonirspTag.task_beam_boundaries(),
-                    beam=beam,
+                self.write(
+                    data=bounds.beam_boundaries_array,
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_beam_boundaries(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
     def compute_average_gain_array(self) -> np.ndarray:
@@ -148,12 +131,10 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
         -------
         The average gain array
         """
-        lin_corr_gain_arrays = self.linearized_frame_full_array_generator(
-            tags=[
-                CryonirspTag.task_solar_gain(),
-                CryonirspTag.linearized(),
-                CryonirspTag.frame(),
-            ]
+        lin_corr_gain_arrays = self.read(
+            tags=[CryonirspTag.linearized_frame(), CryonirspTag.task_solar_gain()],
+            decoder=cryo_fits_array_decoder,
+            fits_access_class=CryonirspLinearizedFitsAccess,
         )
         averaged_gain_data = average_numpy_arrays(lin_corr_gain_arrays)
         return averaged_gain_data

dkist_processing_cryonirsp/tasks/ci_beam_boundaries.py

@@ -3,8 +3,8 @@ import largestinteriorrectangle as lir
 import numpy as np
 from dkist_service_configuration.logging import logger
 
+from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundary
 from dkist_processing_cryonirsp.tasks.beam_boundaries_base import BeamBoundariesCalibrationBase
-from dkist_processing_cryonirsp.tasks.beam_boundaries_base import BeamBoundary
 
 __all__ = ["CIBeamBoundariesCalibration"]
 

dkist_processing_cryonirsp/tasks/ci_science.py

@@ -3,6 +3,7 @@ from collections import defaultdict
 
 from dkist_service_configuration.logging import logger
 
+from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
 from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
@@ -141,22 +142,39 @@ class CIScienceCalibration(ScienceCalibrationBase):
         beam = self.CI_BEAM
         # Load the dark arrays
         for exposure_conditions in self.constants.observe_exposure_conditions_list:
-            dark_array = self.intermediate_frame_load_dark_array(
-                beam=beam, exposure_conditions=exposure_conditions
+            dark_array = next(
+                self.read(
+                    tags=[
+                        CryonirspTag.intermediate_frame(
+                            beam=beam, exposure_conditions=exposure_conditions
+                        ),
+                        CryonirspTag.task_dark(),
+                    ],
+                    decoder=cryo_fits_array_decoder,
+                )
             )
             dark_dict[CryonirspTag.beam(beam)][
                 CryonirspTag.exposure_conditions(exposure_conditions)
             ] = dark_array
 
         # Load the gain arrays
-        solar_dict[CryonirspTag.beam(beam)] = self.intermediate_frame_load_solar_gain_array(
-            beam=beam,
+        solar_dict[CryonirspTag.beam(beam)] = next(
+            self.read(
+                tags=[CryonirspTag.intermediate_frame(beam=beam), CryonirspTag.task_solar_gain()],
+                decoder=cryo_fits_array_decoder,
+            )
         )
 
         # Load the demod matrices
         if self.constants.correct_for_polarization:
-            demod_dict[CryonirspTag.beam(beam)] = self.intermediate_frame_load_demod_matrices(
-                beam=beam
+            demod_dict[CryonirspTag.beam(beam)] = next(
+                self.read(
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_demodulation_matrices(),
+                    ],
+                    decoder=cryo_fits_array_decoder,
+                )
             )
 
         return CalibrationCollection(

dkist_processing_cryonirsp/tasks/cryonirsp_base.py

@@ -7,22 +7,12 @@ from dkist_processing_common.tasks.mixin.quality import QualityMixin
 
 from dkist_processing_cryonirsp.models.constants import CryonirspConstants
 from dkist_processing_cryonirsp.models.parameters import CryonirspParameters
-from dkist_processing_cryonirsp.tasks.mixin.beam_access import BeamAccessMixin
 from dkist_processing_cryonirsp.tasks.mixin.corrections import CorrectionsMixin
-from dkist_processing_cryonirsp.tasks.mixin.intermediate_frame import (
-    IntermediateFrameMixin,
-)
-from dkist_processing_cryonirsp.tasks.mixin.linearized_frame import (
-    LinearizedFrameMixin,
-)
 
 
 class CryonirspTaskBase(
     WorkflowTaskBase,
     InputDatasetMixin,
-    BeamAccessMixin,
-    LinearizedFrameMixin,
-    IntermediateFrameMixin,
     CorrectionsMixin,
     QualityMixin,
     ABC,

dkist_processing_cryonirsp/tasks/dark.py

@@ -1,9 +1,15 @@
 """CryoNIRSP dark calibration task."""
+from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_math.statistics import average_numpy_arrays
 from dkist_service_configuration.logging import logger
 
+from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
+from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundary
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import (
+    CryonirspLinearizedFitsAccess,
+)
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
 
 __all__ = ["DarkCalibration"]
@@ -55,21 +61,32 @@ class DarkCalibration(CryonirspTaskBase):
             f"Calculating dark frames for {self.constants.num_beams} beams and {len(target_exposure_conditions)} exp times"
         ):
             total_dark_frames_used = 0
-            for exposure_conditions in target_exposure_conditions:
-                for beam in range(1, self.constants.num_beams + 1):
+
+            for beam in range(1, self.constants.num_beams + 1):
+                beam_array = next(
+                    self.read(
+                        tags=CryonirspTag.intermediate_beam_boundaries(beam=beam),
+                        decoder=cryo_fits_array_decoder,
+                    )
+                )
+                beam_boundary = BeamBoundary(*beam_array)
+
+                for exposure_conditions in target_exposure_conditions:
                     logger.info(
                         f"Gathering input dark frames for {exposure_conditions = } and {beam = }"
                     )
                     dark_tags = [
-                        CryonirspTag.linearized(),
-                        CryonirspTag.frame(),
+                        CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions),
                         CryonirspTag.task_dark(),
-                        CryonirspTag.exposure_conditions(exposure_conditions),
                     ]
                     current_exp_dark_count = self.scratch.count_all(tags=dark_tags)
                     total_dark_frames_used += current_exp_dark_count
-                    linearized_dark_arrays = self.linearized_frame_dark_array_generator(
-                        exposure_conditions=exposure_conditions, beam=beam
+
+                    linearized_dark_arrays = self.read(
+                        tags=dark_tags,
+                        decoder=cryo_fits_array_decoder,
+                        fits_access_class=CryonirspLinearizedFitsAccess,
+                        beam_boundary=beam_boundary,
                     )
 
                     with self.apm_processing_step(
@@ -80,18 +97,21 @@ class DarkCalibration(CryonirspTaskBase):
                     with self.apm_writing_step(
                         f"Writing dark for {exposure_conditions = } {beam = }"
                     ):
-                        self.intermediate_frame_write_arrays(
-                            averaged_dark_array,
-                            beam=beam,
-                            task_tag=CryonirspTag.task_dark(),
-                            exposure_conditions=exposure_conditions,
+                        self.write(
+                            data=averaged_dark_array,
+                            tags=[
+                                CryonirspTag.intermediate_frame(
+                                    beam=beam, exposure_conditions=exposure_conditions
+                                ),
+                                CryonirspTag.task_dark(),
+                            ],
+                            encoder=fits_array_encoder,
                         )
 
         with self.apm_processing_step("Computing and logging quality metrics"):
             no_of_raw_dark_frames: int = self.scratch.count_all(
                 tags=[
-                    CryonirspTag.linearized(),
-                    CryonirspTag.frame(),
+                    CryonirspTag.linearized_frame(),
                     CryonirspTag.task_dark(),
                 ],
             )