plato-fits 0.11.5__tar.gz → 0.12.0__tar.gz

{plato_fits-0.11.5 → plato_fits-0.12.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: plato-fits
-Version: 0.11.5
+Version: 0.12.0
 Summary: FITS Persistence implementation for CGSE
 Author: IvS KU Leuven
 Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>
 License-Expression: MIT
 Keywords: CGSE,Common-EGSE,hardware testing,software framework
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: astropy>=6.0.1
 Requires-Dist: cgse-common
 Requires-Dist: plato-spw

{plato_fits-0.11.5 → plato_fits-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plato-fits"
-version = "0.11.5"
+version = "0.12.0"
 description = "FITS Persistence implementation for CGSE"
 authors = [
     {name = "IvS KU Leuven"}
@@ -10,7 +10,7 @@ maintainers = [
     {name = "Sara Regibo", email = "sara.regibo@kuleuven.be"}
 ]
 readme = {"file" = "README.md", "content-type" = "text/markdown"}
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = "MIT"
 keywords = [
     "CGSE",

{plato_fits-0.11.5 → plato_fits-0.12.0}/src/egse/plugins/storage/fits.py

@@ -20,19 +20,20 @@ CCD_SETTINGS = Settings.load("CCD")
 
 
 class FITSPersistenceError(Exception):
-    """ Error for the FITS persistence layer."""
+    """Error for the FITS persistence layer."""
+
     pass
 
 
 class FITS(PersistenceLayer):
-    """ Persistence layer that saves (image) data in a FITS file."""
+    """Persistence layer that saves (image) data in a FITS file."""
 
     extension = "fits"
 
-    warnings.simplefilter('ignore', category=AstropyWarning)
+    warnings.simplefilter("ignore", category=AstropyWarning)
 
     def __init__(self, filename: str, prep: dict):
-        """ Initialisation of the FITS persistence layer.
+        """Initialisation of the FITS persistence layer.
 
         This consists of the following steps:
 
@@ -89,15 +90,17 @@ class FITS(PersistenceLayer):
         self.data_arrays = {}
         self.init_data_arrays()
 
-        self.frame_number = {ccd: {self.fee_side.LEFT_SIDE: 0, self.fee_side.RIGHT_SIDE: 0} for ccd in self.selected_ccds}
+        self.frame_number = {
+            ccd: {self.fee_side.LEFT_SIDE: 0, self.fee_side.RIGHT_SIDE: 0} for ccd in self.selected_ccds
+        }
         self.timestamp = None
         self.finetime = None
 
         # How can you know whether or not all data for a given CCD has been received?
         # (this depends on whether or not there is parallel over-scan data and on which CCD side(s) will be transmitted)
 
-        self.expected_last_packet_flags = prep["expected_last_packet_flags"]                    # To be received
-        self.received_last_packet_flags = {ccd: [False] * 4 for ccd in self.selected_ccds}      # Actually received
+        self.expected_last_packet_flags = prep["expected_last_packet_flags"]  # To be received
+        self.received_last_packet_flags = {ccd: [False] * 4 for ccd in self.selected_ccds}  # Actually received
 
         LOGGER.debug(f"Init last packets flag: {self.received_last_packet_flags}")
 
@@ -112,28 +115,27 @@ class FITS(PersistenceLayer):
 
         # Define the values of the WCS keywords
 
-
-        self.v_start = prep["v_start"]                              # First transmitted row
-        self.v_end = prep["v_end"]                                  # Last transmitted row
-        self.h_end = prep["h_end"]                                  # Last transmitted column
-        self.rows_final_dump = prep["rows_final_dump"]              # Number of rows to be dumped after readout
-        self.cycle_time = prep["cycle_time"]                        # Image cycle time [s]
-        self.cgse_version = prep["cgse_version"]                    # Version of the Common EGSE
+        self.v_start = prep["v_start"]  # First transmitted row
+        self.v_end = prep["v_end"]  # Last transmitted row
+        self.h_end = prep["h_end"]  # Last transmitted column
+        self.rows_final_dump = prep["rows_final_dump"]  # Number of rows to be dumped after readout
+        self.cycle_time = prep["cycle_time"]  # Image cycle time [s]
+        self.cgse_version = prep["cgse_version"]  # Version of the Common EGSE
         self.obsid = prep["obsid"]
 
-        self.register_map = prep["register_map"]                    # Register map
+        self.register_map = prep["register_map"]  # Register map
 
         # Read information from the setup
 
         self.setup: Setup = prep["setup"]
 
-        self.site_name = self.setup["site_id"]           # Site ID
-        self.setup_id = self.setup.get_id()              # Setup ID
-        self.camera_id = self.setup.camera.get("ID")     # Camera ID (None if not present in the setup)
+        self.site_name = self.setup["site_id"]  # Site ID
+        self.setup_id = self.setup.get_id()  # Setup ID
+        self.camera_id = self.setup.camera.get("ID")  # Camera ID (None if not present in the setup)
 
-        self.readout_time = self.calculate_readout_time(self.setup)      # Readout time [s]
+        self.readout_time = self.calculate_readout_time(self.setup)  # Readout time [s]
         try:
-            self.exposure_time = self.cycle_time - self.readout_time    # Exposure time [s]
+            self.exposure_time = self.cycle_time - self.readout_time  # Exposure time [s]
         except TypeError:
             # Image cycle time is unknown (None)
             self.exposure_time = None
@@ -152,7 +154,7 @@ class FITS(PersistenceLayer):
         self.is_fits_file_open = False
 
     def calculate_readout_time(self, setup: Setup):
-        """ Calculate the readout time.
+        """Calculate the readout time.
 
         The readout time consists of:
 
@@ -174,13 +176,13 @@ class FITS(PersistenceLayer):
         return time_read_rows + time_dump_rows
 
     def get_vgd(self):
-        """ Extract the VGD voltage from the register map.
+        """Extract the VGD voltage from the register map.
 
         Return: Configured VGD voltage [V].
         """
 
-        vgd_19 = self.register_map[('reg_19_config', 'ccd_vgd_config')]
-        vgd_20 = self.register_map[('reg_20_config', 'ccd_vgd_config')]
+        vgd_19 = self.register_map[("reg_19_config", "ccd_vgd_config")]
+        vgd_20 = self.register_map[("reg_20_config", "ccd_vgd_config")]
 
         return ((vgd_20 << 4) + vgd_19) / 1000 * 5.983
 
@@ -192,11 +194,10 @@ class FITS(PersistenceLayer):
 
         Return: Configured VRD voltage.
         """
-        vrd_18 = self.register_map[('reg_18_config', 'ccd2_vrd_config')]
-        vrd_19 = self.register_map[('reg_19_config', 'ccd2_vrd_config')]
-
-        return int(f'0x{vrd_19:x}{vrd_18:x}', 16)
+        vrd_18 = self.register_map[("reg_18_config", "ccd2_vrd_config")]
+        vrd_19 = self.register_map[("reg_19_config", "ccd2_vrd_config")]
 
+        return int(f"0x{vrd_19:x}{vrd_18:x}", 16)
 
     def get_ccd3_vrd(self):
         """
@@ -206,14 +207,13 @@ class FITS(PersistenceLayer):
 
         Return: Configured VRD voltage.
         """
-        vrd_18 = self.register_map[('reg_18_config', 'ccd3_vrd_config')]
-        vrd_19 = self.register_map[('reg_19_config', 'ccd3_vrd_config')]
-
-        return int(f'0x{vrd_19:x}{vrd_18:x}', 16)
+        vrd_18 = self.register_map[("reg_18_config", "ccd3_vrd_config")]
+        vrd_19 = self.register_map[("reg_19_config", "ccd3_vrd_config")]
 
+        return int(f"0x{vrd_19:x}{vrd_18:x}", 16)
 
     def init_data_arrays(self):
-        """ Initialise data arrays in which the data content of the SpW packets will be dumped.
+        """Initialise data arrays in which the data content of the SpW packets will be dumped.
 
         At this point, we have already determined which side(s) of which CCD(s) will be read out.  For each of them,
         a placeholder will be foreseen in a dedicated dictionary.  The structure of this dictionary is the following,
@@ -241,7 +241,7 @@ class FITS(PersistenceLayer):
         self.data_arrays[self.fee_side.RIGHT_SIDE] = right_side_arrays
 
     def clear_for_next_exposure(self, ccd_number: int, ccd_side):
-        """ Indicate that no data has been received yet for the next exposure of the given CCD.
+        """Indicate that no data has been received yet for the next exposure of the given CCD.
 
         At the end of an exposure, when the data have been assembled and written to FITS:
 
@@ -260,7 +260,7 @@ class FITS(PersistenceLayer):
         self.clear_last_packet_received(ccd_number)
 
     def clear_data_arrays(self, ccd_number: int, ccd_side):
-        """ Clear the data arrays for the given CCD.
+        """Clear the data arrays for the given CCD.
 
         At the end of an exposure, when the data have been assembled and written to FITS, the data arrays must be
         cleared for the next exposure.
@@ -272,7 +272,7 @@ class FITS(PersistenceLayer):
         self.data_arrays[ccd_side][ccd_number] = np.array([], dtype=np.uint16)
 
     def clear_last_packet_received(self, ccd_number: int):
-        """ Clear the information about the last packet being received for the given CCD.
+        """Clear the information about the last packet being received for the given CCD.
 
         At the end of an exposure, when the data have been assembled and written to FITS, it must be indicated that the
         last packet has not been received for the next exposure for the given CCD.
@@ -300,26 +300,30 @@ class FITS(PersistenceLayer):
     #     return self.data_arrays[ccd_side][ccd_number]
 
     def check_readout_mode(self):
-        """ For now only checks whether the N-FEE is in the correct mode, i.e. full-image (pattern) mode.
+        """For now only checks whether the N-FEE is in the correct mode, i.e. full-image (pattern) mode.
 
         In the future, if deemed necessary, windowing (pattern) mode may be implemented as well.
         """
 
-        if self.ccd_mode_config in [n_fee_mode.FULL_IMAGE_MODE, n_fee_mode.FULL_IMAGE_PATTERN_MODE,
-                                    n_fee_mode.PARALLEL_TRAP_PUMPING_1_MODE, n_fee_mode.PARALLEL_TRAP_PUMPING_2_MODE,
-                                    n_fee_mode.SERIAL_TRAP_PUMPING_1_MODE, n_fee_mode.SERIAL_TRAP_PUMPING_2_MODE]:
-
+        if self.ccd_mode_config in [
+            n_fee_mode.FULL_IMAGE_MODE,
+            n_fee_mode.FULL_IMAGE_PATTERN_MODE,
+            n_fee_mode.PARALLEL_TRAP_PUMPING_1_MODE,
+            n_fee_mode.PARALLEL_TRAP_PUMPING_2_MODE,
+            n_fee_mode.SERIAL_TRAP_PUMPING_1_MODE,
+            n_fee_mode.SERIAL_TRAP_PUMPING_2_MODE,
+        ]:
             return False
 
         if self.ccd_mode_config in [n_fee_mode.WINDOWING_PATTERN_MODE, n_fee_mode.WINDOWING_MODE]:
-
             return True
 
         else:
-
-            raise FITSPersistenceError("Construction of FITS files from SpW packets only implemented for full-image "
-                                       "(pattern) mode, windowing (pattern) mode, and parallel/serial trap pumping 1/2 "
-                                       "mode")
+            raise FITSPersistenceError(
+                "Construction of FITS files from SpW packets only implemented for full-image "
+                "(pattern) mode, windowing (pattern) mode, and parallel/serial trap pumping 1/2 "
+                "mode"
+            )
 
     # def init_window_list(self, window_list: dict):
     #     """ Compile the window list.
@@ -399,14 +403,14 @@ class FITS(PersistenceLayer):
     #     return window_indices
 
     def create_primary_header(self):
-        """ Creates the primary header (i.e. the header of the primary HDU).
+        """Creates the primary header (i.e. the header of the primary HDU).
 
         This contains information that is specific for the camera.
         """
 
         primary_header = fits.PrimaryHDU().header
 
-        primary_header["LEVEL"] = 1     # Flat structure
+        primary_header["LEVEL"] = 1  # Flat structure
 
         primary_header["V_START"] = (self.v_start, "Index of 1st row that is transmitted (counting starts at 0)")
         primary_header["V_END"] = (self.v_end, "Index of last row that is transmitted (counting starts at 0)")
@@ -414,38 +418,63 @@ class FITS(PersistenceLayer):
         primary_header["ROWS_FINAL_DUMP"] = (self.rows_final_dump, "Number of rows for clearout after readout")
         primary_header["READ_MODE"] = (n_fee_mode(self.ccd_mode_config).name, "N-FEE operating mode")
 
-        primary_header["CI_WIDTH"] = (self.register_map["charge_injection_width"],
-                                      "Number of rows in each charge injection region")
-        primary_header["CI_GAP"] = (self.register_map["charge_injection_gap"],
-                                    "Number of rows between charge injection regions")
-        primary_header["PARALLEL_TOI_PERIOD"] = (self.register_map["parallel_toi_period"],
-                                                 "Duration of a parallel  overlap period (TOI) [us]")
-        primary_header["PARALLEL_CLK_OVERLAP"] = (self.register_map["parallel_clk_overlap"],
-                                                  "Extra parallel clock overlap [us]")
-        primary_header["CI_EN"] = (self.register_map["charge_injection_width"],
-                                   "Charge injection enabled (1) / disabled (0)")
-        primary_header["TRI_LEVEL_CLK_EN"] = (self.register_map["tri_level_clk_en"],
-                                              "Generating bi-level parallel clocks (0) / tri-level parallel clocks (1)")
-        primary_header["IMG_CLK_DIR"] = (self.register_map["img_clk_dir"],
-                                         "Generating reverse parallel clocks (1) / normal forward parallel clocks (0)")
-        primary_header["REG_CLK_DIR"] = (self.register_map["reg_clk_dir"],
-                                         "Generating reverse serial clocks (1) / normal forward serial clocks (0)")
-        primary_header["PACKET_SIZE"] = (self.register_map["packet_size"],
-                                         "Packet size = load bytes + 10 (header bytes)")
-
-        primary_header["TRAP_PUMP_DWELL_CTR"] = (self.register_map["Trap_Pumping_Dwell_counter"],
-                                                 "Dwell timer for trap pumping [ns]")
+        primary_header["CI_WIDTH"] = (
+            self.register_map["charge_injection_width"],
+            "Number of rows in each charge injection region",
+        )
+        primary_header["CI_GAP"] = (
+            self.register_map["charge_injection_gap"],
+            "Number of rows between charge injection regions",
+        )
+        primary_header["PARALLEL_TOI_PERIOD"] = (
+            self.register_map["parallel_toi_period"],
+            "Duration of a parallel  overlap period (TOI) [us]",
+        )
+        primary_header["PARALLEL_CLK_OVERLAP"] = (
+            self.register_map["parallel_clk_overlap"],
+            "Extra parallel clock overlap [us]",
+        )
+        primary_header["CI_EN"] = (
+            self.register_map["charge_injection_width"],
+            "Charge injection enabled (1) / disabled (0)",
+        )
+        primary_header["TRI_LEVEL_CLK_EN"] = (
+            self.register_map["tri_level_clk_en"],
+            "Generating bi-level parallel clocks (0) / tri-level parallel clocks (1)",
+        )
+        primary_header["IMG_CLK_DIR"] = (
+            self.register_map["img_clk_dir"],
+            "Generating reverse parallel clocks (1) / normal forward parallel clocks (0)",
+        )
+        primary_header["REG_CLK_DIR"] = (
+            self.register_map["reg_clk_dir"],
+            "Generating reverse serial clocks (1) / normal forward serial clocks (0)",
+        )
+        primary_header["PACKET_SIZE"] = (
+            self.register_map["packet_size"],
+            "Packet size = load bytes + 10 (header bytes)",
+        )
+
+        primary_header["TRAP_PUMP_DWELL_CTR"] = (
+            self.register_map["Trap_Pumping_Dwell_counter"],
+            "Dwell timer for trap pumping [ns]",
+        )
         primary_header["SENSOR_SEL"] = (self.register_map["sensor_sel"], "CCD port data transmission selection control")
         primary_header["SYNC_SEL"] = (self.register_map["sync_sel"], "Internal (1) / external (0) sync")
-        primary_header["DIGITISE_EN"] = (self.register_map["digitise_en"],
-                                         "Digitised data transferred to the N-DPU (1) or not (0) during image mode")
+        primary_header["DIGITISE_EN"] = (
+            self.register_map["digitise_en"],
+            "Digitised data transferred to the N-DPU (1) or not (0) during image mode",
+        )
         primary_header["DG_EN"] = (self.register_map["DG_en"], "Dump gate high (1) / low (0)")
         primary_header["CCD_READ_EN"] = (self.register_map["ccd_read_en"], "CCD readout enabled (1) / disabled (0)")
-        primary_header["CONV_DLY"] = (self.register_map["conv_dly"],
-                                      "Delay value from rising edge of CCD_R_EF_DRV (where ADC convert pulse "
-                                      "is generated) [ns]")
-        primary_header["HIGH_PRECISION_HK_EN"] = (self.register_map["High_precision_HK_en"],
-                                                  "Sending high-precision HK (1) / pixel data (0)")
+        primary_header["CONV_DLY"] = (
+            self.register_map["conv_dly"],
+            "Delay value from rising edge of CCD_R_EF_DRV (where ADC convert pulse is generated) [ns]",
+        )
+        primary_header["HIGH_PRECISION_HK_EN"] = (
+            self.register_map["High_precision_HK_en"],
+            "Sending high-precision HK (1) / pixel data (0)",
+        )
 
         primary_header["CCD_VOD"] = (self.register_map["ccd_vod_config"], "Configured VOD")
 
@@ -464,27 +493,37 @@ class FITS(PersistenceLayer):
         primary_header["CCD_IG_LO"] = (self.register_map["ccd_ig_lo_config"], "Configured IG-high")
         primary_header["TRK_HLD_HI"] = (self.register_map["trk_hld_hi"], "Track and hold high")
         primary_header["TRK_HLD_LO"] = (self.register_map["trk_hld_lo"], "Track and hold low")
-        primary_header["CONT_RST_ON"] = (self.register_map["cont_rst_on"],
-                                         "When 1, FPGA generates continuous reset clock during readout")
+        primary_header["CONT_RST_ON"] = (
+            self.register_map["cont_rst_on"],
+            "When 1, FPGA generates continuous reset clock during readout",
+        )
         if not PLATO_CAMERA_IS_EM:
-            primary_header["CONT_CDSCLP_ON"] = (self.register_map["cont_cdsclp_on"],
-                                                "When 1, FPGA generates continuous CDS clamp during readout")
-            primary_header["CONT_ROWCLP_ON"] = (self.register_map["cont_rowclp_on"],
-                                                "When 1, FPGA generates continuous row clamp during readout")
+            primary_header["CONT_CDSCLP_ON"] = (
+                self.register_map["cont_cdsclp_on"],
+                "When 1, FPGA generates continuous CDS clamp during readout",
+            )
+            primary_header["CONT_ROWCLP_ON"] = (
+                self.register_map["cont_rowclp_on"],
+                "When 1, FPGA generates continuous row clamp during readout",
+            )
         primary_header["R_CFG1"] = (self.register_map["r_cfg1"], "Clock cycle for Rph3-low, Rph1-high")
         primary_header["R_CFG2"] = (self.register_map["r_cfg2"], "Clock cycle for Rph1-low, Rph2-high")
         primary_header["CDSCLP_LO"] = (self.register_map["cdsclp_lo"], "Clock cycle for cdsclp low")
         if not PLATO_CAMERA_IS_EM:
-            primary_header["ADC_PWRDN_EN"] = (self.register_map["adc_pwrdn_en"],
-                                              "ADC power-down enabled (0) / disabled (1)")
+            primary_header["ADC_PWRDN_EN"] = (
+                self.register_map["adc_pwrdn_en"],
+                "ADC power-down enabled (0) / disabled (1)",
+            )
             primary_header["CDSCLP_HI"] = (self.register_map["cdsclp_hi"], "Clock cycle for cdsclp high")
             primary_header["ROWCLP_HI"] = (self.register_map["rowclp_hi"], "Clock cycle for rowclp high")
             primary_header["ROWCLP_LO"] = (self.register_map["rowclp_lo"], "Clock cycle for rowclp low")
         # primary_header["SURFACE_INV_CTR"] = (self.register_map["Surface_Inversion_counter"],
         #                                      "Surface inversion counter")
         primary_header["READOUT_PAUSE_CTR"] = (self.register_map["Readout_pause_counter"], "Readout pause counter")
-        primary_header["TRAP_PUMP_SHUFFLE_CTR"] = (self.register_map["Trap_Pumping_Shuffle_counter"],
-                                                   "Trap pumping shuffle counter")
+        primary_header["TRAP_PUMP_SHUFFLE_CTR"] = (
+            self.register_map["Trap_Pumping_Shuffle_counter"],
+            "Trap pumping shuffle counter",
+        )
 
         # primary_header["FOCALLEN"] = (FOV_SETTINGS["FOCAL_LENGTH"], "Focal length [mm]")
 
@@ -497,40 +536,50 @@ class FITS(PersistenceLayer):
         primary_header["SETUP"] = (self.setup_id, "Setup ID")
         primary_header["CCD_READOUT_ORDER"] = (str(self.ccd_readout_order), "Transmitted CCDs")
         primary_header["CYCLETIME"] = (self.cycle_time, "Image cycle time [s]")
-        primary_header["READTIME"] = (self.readout_time,
-                                      "Time needed to read out the requested part for a single CCD side [s]")
+        primary_header["READTIME"] = (
+            self.readout_time,
+            "Time needed to read out the requested part for a single CCD side [s]",
+        )
 
         if self.register_map["sync_sel"] == 1:  # See https://github.com/IvS-KULeuven/plato-common-egse/issues/2475
-            primary_header["READPERIOD"] = (self.cycle_time + INT_SYNC_TIMING_OFFSET, "Time between frames [s] "
-                                                                                       "(internal sync)")
+            primary_header["READPERIOD"] = (
+                self.cycle_time + INT_SYNC_TIMING_OFFSET,
+                "Time between frames [s] (internal sync)",
+            )
             texp_cmd = self.cycle_time - self.readout_time
             primary_header["TEXP_CMD"] = (texp_cmd, "Commanded exposure time [s] (internal sync)")
-            primary_header["TEXP_EFF"] = (texp_cmd + INT_SYNC_TIMING_OFFSET, "Effective exposure time [s] (internal "
-                                                                              "sync)")
+            primary_header["TEXP_EFF"] = (
+                texp_cmd + INT_SYNC_TIMING_OFFSET,
+                "Effective exposure time [s] (internal sync)",
+            )
 
         primary_header["CGSE"] = (self.cgse_version, "Version of the Common EGSE")
 
         LOGGER.info(f"Obsid in FITS persistence layer: {self.obsid}")
 
         if self.obsid is not None:
-
             LOGGER.debug(f"{self.obsid = }")
 
             primary_header["OBSID"] = (self.obsid, "Observation identifier")
 
-        primary_header["PRE_SC_N"] = (CCD_SETTINGS.LENGTH_SERIAL_PRESCAN,
-                                      "Number of pixels/columns in the serial pre-scan")
-        primary_header["OVR_SC_N"] = (max(0, self.h_end + 1
-                                          - CCD_SETTINGS.LENGTH_SERIAL_PRESCAN - CCD_SETTINGS.NUM_COLUMNS // 2),
-                                      "Number of virtual pixels / columns in the serial over-scan")
-        primary_header["OVR_SC_R"] = (max(0, self.v_end + 1 - CCD_SETTINGS.NUM_ROWS),
-                                      "Number of rows in the parallel over-scan")
+        primary_header["PRE_SC_N"] = (
+            CCD_SETTINGS.LENGTH_SERIAL_PRESCAN,
+            "Number of pixels/columns in the serial pre-scan",
+        )
+        primary_header["OVR_SC_N"] = (
+            max(0, self.h_end + 1 - CCD_SETTINGS.LENGTH_SERIAL_PRESCAN - CCD_SETTINGS.NUM_COLUMNS // 2),
+            "Number of virtual pixels / columns in the serial over-scan",
+        )
+        primary_header["OVR_SC_R"] = (
+            max(0, self.v_end + 1 - CCD_SETTINGS.NUM_ROWS),
+            "Number of rows in the parallel over-scan",
+        )
         primary_header["IMG_REPR"] = ("FOV_IMG", "Right CCD side flipped w.r.t. readout direction")
 
         return primary_header
 
     def create_base_image_wcs(self):
-        """ Create a basic FITS header for the image.
+        """Create a basic FITS header for the image.
 
         Not all information can be filled out at this point (i.c. extension, CCD identifier, number of columns,
         rotation, reference pixel).  This will be done at the moment the serial pre-scan will be written to file.
@@ -553,29 +602,55 @@ class FITS(PersistenceLayer):
 
         num_rows = min(CCD_SETTINGS["NUM_ROWS"] - 1, self.v_end) - self.v_start + 1
 
-        image_header["NAXIS"] = (2, "Dimensionality of the image",)
-        image_header["NAXIS2"] = (num_rows, "Number of rows in the image",)
-
+        image_header["NAXIS"] = (
+            2,
+            "Dimensionality of the image",
+        )
+        image_header["NAXIS2"] = (
+            num_rows,
+            "Number of rows in the image",
+        )
 
         # Focal length (this is needed for the conversion to field angles)
 
-        image_header["FOCALLEN"] = (FOV_SETTINGS["FOCAL_LENGTH"], "Focal length [mm]",) # TODO
+        image_header["FOCALLEN"] = (
+            FOV_SETTINGS["FOCAL_LENGTH"],
+            "Focal length [mm]",
+        )  # TODO
 
         # Linear coordinate transformation from sub-field to focal-plane coordinates
 
-        image_header["ctype1"] = ("LINEAR", "Linear coordinate transformation",)
-        image_header["ctype2"] = ("LINEAR", "Linear coordinate transformation",)
+        image_header["ctype1"] = (
+            "LINEAR",
+            "Linear coordinate transformation",
+        )
+        image_header["ctype2"] = (
+            "LINEAR",
+            "Linear coordinate transformation",
+        )
 
         # Focal-plane coordinates are expressed in mm
 
-        image_header["CUNIT1"] = ("MM", "Target unit in the column direction (mm)",)
-        image_header["CUNIT2"] = ("MM", "Target unit in the row direction (mm)",)
+        image_header["CUNIT1"] = (
+            "MM",
+            "Target unit in the column direction (mm)",
+        )
+        image_header["CUNIT2"] = (
+            "MM",
+            "Target unit in the row direction (mm)",
+        )
 
         # Pixel size
 
         cdelt = CCD_SETTINGS["PIXEL_SIZE"] / 1000.0  # Pixel size [mm]
-        image_header["CDELT1"] = (cdelt, "Pixel size in the x-direction [mm]",)
-        image_header["CDELT2"] = (cdelt, "Pixel size in the y-direction [mm]",)
+        image_header["CDELT1"] = (
+            cdelt,
+            "Pixel size in the x-direction [mm]",
+        )
+        image_header["CDELT2"] = (
+            cdelt,
+            "Pixel size in the y-direction [mm]",
+        )
 
         # Additional keywords
 
@@ -593,7 +668,7 @@ class FITS(PersistenceLayer):
         return image_header
 
     def create_base_serial_prescan_wcs(self):
-        """ Create a basic FITS header for the serial pre-scan.
+        """Create a basic FITS header for the serial pre-scan.
 
         Not all information can be filled out at this point (i.c. extension, CCD identifier).  This will be
         done at the moment the serial pre-scan will be written to file.
@@ -616,9 +691,18 @@ class FITS(PersistenceLayer):
         num_rows = self.v_end - self.v_start + 1
         num_columns = CCD_SETTINGS.LENGTH_SERIAL_PRESCAN
 
-        serial_prescan_wcs["NAXIS"] = (2, "Dimensionality of the serial pre-scan",)
-        serial_prescan_wcs["NAXIS1"] = (num_columns, "Number of columns in the serial pre-scan",)
-        serial_prescan_wcs["NAXIS2"] = (num_rows, "Number of rows in the serial pre-scan",)
+        serial_prescan_wcs["NAXIS"] = (
+            2,
+            "Dimensionality of the serial pre-scan",
+        )
+        serial_prescan_wcs["NAXIS1"] = (
+            num_columns,
+            "Number of columns in the serial pre-scan",
+        )
+        serial_prescan_wcs["NAXIS2"] = (
+            num_rows,
+            "Number of rows in the serial pre-scan",
+        )
 
         serial_prescan_wcs["TELESCOP"] = "PLATO"
         if self.camera_id:
@@ -631,7 +715,7 @@ class FITS(PersistenceLayer):
         return serial_prescan_wcs
 
     def create_base_serial_overscan_wcs(self):
-        """ Create a basic FITS header for the serial over-scan.
+        """Create a basic FITS header for the serial over-scan.
 
         Not all information can be filled out at this point (i.c. extension, CCD identifier).  This will be
         done at the moment the serial over-scan will be written to file.
@@ -654,9 +738,18 @@ class FITS(PersistenceLayer):
         num_rows = self.v_end - self.v_start + 1
         num_columns = self.v_end + 1 - CCD_SETTINGS.LENGTH_SERIAL_PRESCAN - CCD_SETTINGS.NUM_COLUMNS / 2
 
-        serial_overscan_wcs["NAXIS"] = (2, "Dimensionality of the serial over-scan",)
-        serial_overscan_wcs["NAXIS1"] = (num_columns, "Number of columns in the serial over-scan",)
-        serial_overscan_wcs["NAXIS2"] = (num_rows, "Number of rows in the serial over-scan",)
+        serial_overscan_wcs["NAXIS"] = (
+            2,
+            "Dimensionality of the serial over-scan",
+        )
+        serial_overscan_wcs["NAXIS1"] = (
+            num_columns,
+            "Number of columns in the serial over-scan",
+        )
+        serial_overscan_wcs["NAXIS2"] = (
+            num_rows,
+            "Number of rows in the serial over-scan",
+        )
 
         # Site name
 
@@ -671,7 +764,7 @@ class FITS(PersistenceLayer):
         return serial_overscan_wcs
 
     def create_base_parallel_overscan_wcs(self):
-        """ Create a basic FITS header for the parallel over-scan.
+        """Create a basic FITS header for the parallel over-scan.
 
         Not all information can be filled out at this point (i.c. extension, CCD identifier, number of columns).  This
         will be done at the moment the parallel over-scan will be written to file.
@@ -694,8 +787,14 @@ class FITS(PersistenceLayer):
 
         num_rows_parallel_overscan = max(0, self.v_end - CCD_SETTINGS.NUM_ROWS + 1)
 
-        parallel_overscan_wcs["NAXIS"] = (2, "Dimensionality of the parallel over-scan",)
-        parallel_overscan_wcs["NAXIS2"] = (num_rows_parallel_overscan, "Number of rows in the parallel over-scan",)
+        parallel_overscan_wcs["NAXIS"] = (
+            2,
+            "Dimensionality of the parallel over-scan",
+        )
+        parallel_overscan_wcs["NAXIS2"] = (
+            num_rows_parallel_overscan,
+            "Number of rows in the parallel over-scan",
+        )
 
         # Site name
 
@@ -710,7 +809,6 @@ class FITS(PersistenceLayer):
         return parallel_overscan_wcs
 
     def open(self, mode=None):
-
         primary_header = self.create_primary_header()
 
         # The primary HDU contains only this header and no image data
@@ -731,7 +829,6 @@ class FITS(PersistenceLayer):
         self.is_fits_file_open = False
 
     def exists(self):
-
         return self._filepath.exists()
 
     def create(self, data: dict):
@@ -744,24 +841,21 @@ class FITS(PersistenceLayer):
         """
 
         for key, spw_packet in data.items():
-
             # if isinstance(spw_packet, TimecodePacket):
             #
             #     self.timestamp = spw_packet.
 
             if key == "Timestamp":
-
                 self.timestamp = spw_packet
                 self.finetime = time_since_epoch_1958(self.timestamp)
 
             elif isinstance(spw_packet, DataPacket):
-
                 try:
                     ccd_bin_to_id = self.setup.camera.fee.ccd_numbering.CCD_BIN_TO_ID
                 except AttributeError:
                     raise SetupError("No entry in the setup for camera.fee.ccd_numbering.CCD_BIN_TO_ID")
                 spw_packet_data_type = spw_packet.type
-                ccd_number = ccd_bin_to_id[spw_packet_data_type.ccd_number] # 1-4
+                ccd_number = ccd_bin_to_id[spw_packet_data_type.ccd_number]  # 1-4
                 ccd_side = self.fee_side(spw_packet_data_type.ccd_side)
                 data_array = spw_packet.data_as_ndarray
 
@@ -778,11 +872,9 @@ class FITS(PersistenceLayer):
                 #   - add to the FITS file.
 
                 if self.is_all_data_received(spw_packet_data_type, ccd_number, ccd_side):
-
                     # Write the information to FITS
 
                     for ccd_side in self.fee_side:
-
                         try:
                             if self.data_arrays[ccd_side][ccd_number].size > 0:
                                 self.assemble_slice(ccd_number, ccd_side)
@@ -795,7 +887,7 @@ class FITS(PersistenceLayer):
                     self.clear_for_next_exposure(ccd_number, ccd_side)
 
     def is_all_data_received(self, spw_packet_data_type: DataPacketType, ccd_number: int, ccd_side):
-        """ Check if all data has been received for the current exposure.
+        """Check if all data has been received for the current exposure.
 
         Args:
             - spw_packet_data_type: Last received data packet type.
@@ -808,33 +900,26 @@ class FITS(PersistenceLayer):
         from egse.dpu import got_all_last_packets
 
         if spw_packet_data_type.last_packet:
-
             packet_type = spw_packet_data_type.packet_type
 
             if packet_type == PacketType.DATA_PACKET:
-
                 if ccd_side == self.fee_side.E_SIDE:
-
                     self.received_last_packet_flags[ccd_number][0] = True
 
                 elif ccd_side == self.fee_side.F_SIDE:
-
                     self.received_last_packet_flags[ccd_number][1] = True
 
             elif packet_type == PacketType.OVERSCAN_DATA:
-
                 if ccd_side == self.fee_side.E_SIDE:
-
                     self.received_last_packet_flags[ccd_number][2] = True
 
                 elif ccd_side == self.fee_side.F_SIDE:
-
                     self.received_last_packet_flags[ccd_number][3] = True
 
         return got_all_last_packets(self.received_last_packet_flags[ccd_number], self.expected_last_packet_flags)
 
     def got_all_last_packets(self, ccd_number: int, ccd_side):
-        """ Check whether all the expected last-packet  flags have been seen for the given CCD side.
+        """Check whether all the expected last-packet  flags have been seen for the given CCD side.
 
         Args:
             - ccd_number: CCD from which the last received data originates (1-4).
@@ -847,19 +932,21 @@ class FITS(PersistenceLayer):
         received_last_packet_flags = self.received_last_packet_flags[ccd_number]
 
         if ccd_side == self.fee_side.E_SIDE:
-
-            return received_last_packet_flags[0] == self.expected_last_packet_flags[0] \
-                   and received_last_packet_flags[2] == self.expected_last_packet_flags[2]
+            return (
+                received_last_packet_flags[0] == self.expected_last_packet_flags[0]
+                and received_last_packet_flags[2] == self.expected_last_packet_flags[2]
+            )
 
         elif ccd_side == self.fee_side.F_SIDE:
-
-            return received_last_packet_flags[1] == self.expected_last_packet_flags[1] \
-                   and received_last_packet_flags[3] == self.expected_last_packet_flags[3]
+            return (
+                received_last_packet_flags[1] == self.expected_last_packet_flags[1]
+                and received_last_packet_flags[3] == self.expected_last_packet_flags[3]
+            )
 
         return False
 
     def assemble_slice(self, ccd_number: int, ccd_side):
-        """ Assemble the data for the given CCD and write it to FITS.
+        """Assemble the data for the given CCD and write it to FITS.
 
         Args:
             - ccd_number: CCD identifier (1/2/3/4).
@@ -868,14 +955,12 @@ class FITS(PersistenceLayer):
         # Windowing (pattern) mode
 
         if self.is_windowing_mode:
-
             # self.assemble_slice_windowing_mode(ccd_number, ccd_side)
             pass
 
         # Full-image (pattern) mode
 
         else:
-
             self.assemble_slice_full_image_mode(ccd_number, ccd_side)
 
     # def assemble_slice_windowing_mode(self, ccd_number: int):
@@ -959,7 +1044,7 @@ class FITS(PersistenceLayer):
     #     self.append_image(image, ccd_number)
 
     def assemble_slice_full_image_mode(self, ccd_number: int, ccd_side):
-        """ Assemble the data for the given CCD and write it to FITS, for full-image mode or full-image pattern mode.
+        """Assemble the data for the given CCD and write it to FITS, for full-image mode or full-image pattern mode.
 
         This consists of the following steps:
 
@@ -986,13 +1071,16 @@ class FITS(PersistenceLayer):
         # Re-shape the 1D array to a 2D array and extract the image and scan maps
 
         try:
-            data_array = np.reshape(self.data_arrays[ccd_side][ccd_number], (num_rows, num_columns))    # 1D -> 2D
+            data_array = np.reshape(self.data_arrays[ccd_side][ccd_number], (num_rows, num_columns))  # 1D -> 2D
         except ValueError as exc:
-            raise MissingSpWPacketsError(f"Incomplete SpW data for frame {self.frame_number[ccd_number][ccd_side]} "
-                                         f"for the {ccd_side.name[0]}-side off CCD{ccd_number}.  Check the DPU "
-                                         f"Processing logs for more information.") from exc
-        side_image, side_serial_prescan, side_serial_overscan, side_parallel_overscan = \
-            self.extract_full_image_mode(data_array)
+            raise MissingSpWPacketsError(
+                f"Incomplete SpW data for frame {self.frame_number[ccd_number][ccd_side]} "
+                f"for the {ccd_side.name[0]}-side off CCD{ccd_number}.  Check the DPU "
+                f"Processing logs for more information."
+            ) from exc
+        side_image, side_serial_prescan, side_serial_overscan, side_parallel_overscan = self.extract_full_image_mode(
+            data_array
+        )
 
         # Serial pre-scan
 
@@ -1001,13 +1089,11 @@ class FITS(PersistenceLayer):
         # Serial over-scan
 
         if self.has_serial_overscan:
-
             self.append_serial_overscan(side_serial_overscan, ccd_number, ccd_side)
 
         # Parallel over-scan
 
         if self.has_parallel_overscan:
-
             self.append_parallel_overscan(side_parallel_overscan, ccd_number, ccd_side)
 
         # Image
@@ -1037,42 +1123,40 @@ class FITS(PersistenceLayer):
         #     the row index of the first transmitted parallel over-scan row).
 
         start_column_image = CCD_SETTINGS.LENGTH_SERIAL_PRESCAN
-        end_column_image_plus_1 = min(CCD_SETTINGS.LENGTH_SERIAL_PRESCAN + CCD_SETTINGS.NUM_COLUMNS // 2, self.h_end + 1)
+        end_column_image_plus_1 = min(
+            CCD_SETTINGS.LENGTH_SERIAL_PRESCAN + CCD_SETTINGS.NUM_COLUMNS // 2, self.h_end + 1
+        )
         end_row_image_plus_1 = min(CCD_SETTINGS.NUM_ROWS - 1, self.v_end) - self.v_start + 1
 
         # Serial pre-scan (all rows, but only the first couple of rows)
 
-        serial_prescan = data_array[:, 0: start_column_image]
+        serial_prescan = data_array[:, 0:start_column_image]
 
         # Serial over-scan (all rows, omit the columns from the serial pre-scan and the serial over-scan)
 
         if self.has_serial_overscan:
-
             serial_overscan = data_array[:, end_column_image_plus_1:]
 
         else:
-
             serial_overscan = None
 
         # Image (omit the rows from the parallel over-scan
         # and the columns from the serial pre-scan and the serial over-scan)
 
-        image = data_array[0: end_row_image_plus_1, start_column_image: end_column_image_plus_1]
+        image = data_array[0:end_row_image_plus_1, start_column_image:end_column_image_plus_1]
 
         # Parallel over-scan
 
         if self.has_parallel_overscan:
-
-            parallel_overscan = data_array[end_row_image_plus_1:, start_column_image: end_column_image_plus_1]
+            parallel_overscan = data_array[end_row_image_plus_1:, start_column_image:end_column_image_plus_1]
 
         else:
-
             parallel_overscan = None
 
         return image, serial_prescan, serial_overscan, parallel_overscan
 
     def append_serial_prescan(self, serial_prescan, ccd_number: int, ccd_side: str):
-        """ Append the given serial pre-scan to the FITS file (after completing its header).
+        """Append the given serial pre-scan to the FITS file (after completing its header).
 
         Args:
             - serial_prescan: Serial pre-scan.
@@ -1083,10 +1167,19 @@ class FITS(PersistenceLayer):
         extension = f"SPRE_{ccd_number}_{self.fee_side(ccd_side).name[0]}"
         self.serial_prescan_header["EXTNAME"] = extension
         self.serial_prescan_header["EXTVER"] = self.frame_number[ccd_number][ccd_side]
-        self.serial_prescan_header["CCD_ID"] = (ccd_number, "CCD identifier",)
+        self.serial_prescan_header["CCD_ID"] = (
+            ccd_number,
+            "CCD identifier",
+        )
         self.serial_prescan_header["SENSOR_SEL"] = (self.fee_side(ccd_side).name[0], "CCD side")
-        self.serial_prescan_header["DATE-OBS"] = (self.timestamp, "Timestamp for 1st frame",)
-        self.serial_prescan_header["FINETIME"] = (self.finetime, "Finetime representation of DATE-OBS",)
+        self.serial_prescan_header["DATE-OBS"] = (
+            self.timestamp,
+            "Timestamp for 1st frame",
+        )
+        self.serial_prescan_header["FINETIME"] = (
+            self.finetime,
+            "Finetime representation of DATE-OBS",
+        )
 
         if ccd_side in [self.fee_side.RIGHT_SIDE.name, self.fee_side.RIGHT_SIDE]:
             serial_prescan = np.fliplr(serial_prescan)
@@ -1094,7 +1187,7 @@ class FITS(PersistenceLayer):
         fits.append(str(self._filepath), serial_prescan, self.serial_prescan_header)
 
     def append_serial_overscan(self, serial_overscan, ccd_number: int, ccd_side: str):
-        """ Append the given serial over-scan to the FITS file (after completing its header).
+        """Append the given serial over-scan to the FITS file (after completing its header).
 
         Args:
             - serial_overscan: Serial over-scan.
@@ -1105,10 +1198,19 @@ class FITS(PersistenceLayer):
         extension = f"SOVER_{ccd_number}_{self.fee_side(ccd_side).name[0]}"
         self.serial_overscan_header["EXTNAME"] = extension
         self.serial_overscan_header["EXTVER"] = self.frame_number[ccd_number][ccd_side]
-        self.serial_overscan_header["CCD_ID"] = (ccd_number, "CCD identifier",)
+        self.serial_overscan_header["CCD_ID"] = (
+            ccd_number,
+            "CCD identifier",
+        )
         self.serial_overscan_header["SENSOR_SEL"] = (self.fee_side(ccd_side).name[0], "CCD side")
-        self.serial_overscan_header["NAXIS1"] = (serial_overscan.shape[1], "Number of columns in the serial over-scan",)
-        self.serial_overscan_header["DATE-OBS"] = (self.timestamp, "Timestamp for 1st frame",)
+        self.serial_overscan_header["NAXIS1"] = (
+            serial_overscan.shape[1],
+            "Number of columns in the serial over-scan",
+        )
+        self.serial_overscan_header["DATE-OBS"] = (
+            self.timestamp,
+            "Timestamp for 1st frame",
+        )
         self.serial_overscan_header["FINETIME"] = (self.finetime, "Finetime representation of DATE-OBS")
 
         if ccd_side in [self.fee_side.RIGHT_SIDE.name, self.fee_side.RIGHT_SIDE]:
@@ -1117,7 +1219,7 @@ class FITS(PersistenceLayer):
         fits.append(str(self._filepath), serial_overscan, self.serial_overscan_header)
 
     def append_parallel_overscan(self, parallel_overscan, ccd_number: int, ccd_side: str):
-        """ Append the given parallel over-scan to the FITS file (after completing its header).
+        """Append the given parallel over-scan to the FITS file (after completing its header).
 
         Args:
             - parallel_overscan: Parallel over-scan.
@@ -1128,12 +1230,23 @@ class FITS(PersistenceLayer):
         extension = f"POVER_{ccd_number}_{self.fee_side(ccd_side).name[0]}"
         self.parallel_overscan_header["EXTNAME"] = extension
         self.parallel_overscan_header["EXTVER"] = self.frame_number[ccd_number][ccd_side]
-        self.parallel_overscan_header["CCD_ID"] = (ccd_number, "CCD identifier",)
+        self.parallel_overscan_header["CCD_ID"] = (
+            ccd_number,
+            "CCD identifier",
+        )
         self.parallel_overscan_header["SENSOR_SEL"] = (self.fee_side(ccd_side).name[0], "CCD side")
-        self.parallel_overscan_header["NAXIS1"] = (parallel_overscan.shape[1],
-                                                   "Number of columns in the parallel over-scan",)
-        self.parallel_overscan_header["DATE-OBS"] = (self.timestamp, "Timestamp for 1st frame",)
-        self.parallel_overscan_header["FINETIME"] = (self.finetime, "Finetime representation of DATE-OBS",)
+        self.parallel_overscan_header["NAXIS1"] = (
+            parallel_overscan.shape[1],
+            "Number of columns in the parallel over-scan",
+        )
+        self.parallel_overscan_header["DATE-OBS"] = (
+            self.timestamp,
+            "Timestamp for 1st frame",
+        )
+        self.parallel_overscan_header["FINETIME"] = (
+            self.finetime,
+            "Finetime representation of DATE-OBS",
+        )
 
         if ccd_side in [self.fee_side.RIGHT_SIDE.name, self.fee_side.RIGHT_SIDE]:
             parallel_overscan = np.fliplr(parallel_overscan)
@@ -1141,7 +1254,7 @@ class FITS(PersistenceLayer):
         fits.append(str(self._filepath), parallel_overscan, self.parallel_overscan_header)
 
     def append_image(self, image, ccd_number: int, ccd_side: str):
-        """ Append the given image to the FITS file (after completing its header).
+        """Append the given image to the FITS file (after completing its header).
 
         Args:
             - image: Image.
@@ -1152,46 +1265,82 @@ class FITS(PersistenceLayer):
         extension = f"IMAGE_{ccd_number}_{self.fee_side(ccd_side).name[0]}"
         self.image_header["EXTNAME"] = extension
         self.image_header["EXTVER"] = self.frame_number[ccd_number][ccd_side]
-        self.image_header["CCD_ID"] = (ccd_number, "CCD identifier",)
+        self.image_header["CCD_ID"] = (
+            ccd_number,
+            "CCD identifier",
+        )
         self.image_header["SENSOR_SEL"] = (self.fee_side(ccd_side).name[0], "CCD side")
-        self.image_header["NAXIS1"] = (image.shape[1], "Number of columns in the image",)
+        self.image_header["NAXIS1"] = (
+            image.shape[1],
+            "Number of columns in the image",
+        )
 
         ccd_orientation_degrees = CCD_SETTINGS.ORIENTATION[ccd_number - 1]
         ccd_orientation_radians = radians(ccd_orientation_degrees)
 
-        self.image_header["CROTA2"] = (ccd_orientation_degrees, "CCD orientation angle [degrees]",)
+        self.image_header["CROTA2"] = (
+            ccd_orientation_degrees,
+            "CCD orientation angle [degrees]",
+        )
 
         cdelt = CCD_SETTINGS["PIXEL_SIZE"] / 1000.0  # Pixel size [mm]
 
-        self.image_header["CD1_1"] = (cdelt * cos(ccd_orientation_radians),
-                                      "Pixel size x cos(CCD orientation angle)",)
-        self.image_header["CD1_2"] = (-cdelt * sin(ccd_orientation_radians),
-                                      "-Pixel size x sin(CCD orientation angle)",)
-        self.image_header["CD2_1"] = (cdelt * sin(ccd_orientation_radians),
-                                      "Pixel size x sin(CCD orientation angle)",)
-        self.image_header["CD2_2"] = (cdelt * cos(ccd_orientation_radians),
-                                      "Pixel size x cos(CCD orientation angle)",)
+        self.image_header["CD1_1"] = (
+            cdelt * cos(ccd_orientation_radians),
+            "Pixel size x cos(CCD orientation angle)",
+        )
+        self.image_header["CD1_2"] = (
+            -cdelt * sin(ccd_orientation_radians),
+            "-Pixel size x sin(CCD orientation angle)",
+        )
+        self.image_header["CD2_1"] = (
+            cdelt * sin(ccd_orientation_radians),
+            "Pixel size x sin(CCD orientation angle)",
+        )
+        self.image_header["CD2_2"] = (
+            cdelt * cos(ccd_orientation_radians),
+            "Pixel size x cos(CCD orientation angle)",
+        )
 
         zeropoint_x, zeropoint_y = -np.array(CCD_SETTINGS.ZEROPOINT)
         crval1 = zeropoint_x * cos(ccd_orientation_radians) - zeropoint_y * sin(ccd_orientation_radians)
         crval2 = zeropoint_x * sin(ccd_orientation_radians) + zeropoint_y * cos(ccd_orientation_radians)
 
-        self.image_header["CRVAL1"] = (crval1, "FP x-coordinate of the CCD origin [mm]",)
-        self.image_header["CRVAL2"] = (crval2, "FP y-coordinate of the CCD origin [mm]",)
+        self.image_header["CRVAL1"] = (
+            crval1,
+            "FP x-coordinate of the CCD origin [mm]",
+        )
+        self.image_header["CRVAL2"] = (
+            crval2,
+            "FP y-coordinate of the CCD origin [mm]",
+        )
 
-        self.image_header["CRPIX2"] = (-self.v_start,
-                                       "CCD origin row wrt 1st transmitted row",)
+        self.image_header["CRPIX2"] = (
+            -self.v_start,
+            "CCD origin row wrt 1st transmitted row",
+        )
 
         if ccd_side in [self.fee_side.LEFT_SIDE.name, self.fee_side.LEFT_SIDE]:
-            self.image_header["CRPIX1"] = (0, "CCD origin column wrt lower left corner",)
+            self.image_header["CRPIX1"] = (
+                0,
+                "CCD origin column wrt lower left corner",
+            )
 
         if ccd_side in [self.fee_side.RIGHT_SIDE.name, self.fee_side.RIGHT_SIDE]:
             image = np.fliplr(image)
-            self.image_header["CRPIX1"] = (-CCD_SETTINGS.NUM_ROWS + image.shape[1],
-                                           "CCD origin column wrt lower left corner")
-
-        self.image_header["DATE-OBS"] = (self.timestamp, "Timestamp for 1st frame",)
-        self.image_header["FINETIME"] = (self.finetime, "Finetime representation of DATE-OBS",)
+            self.image_header["CRPIX1"] = (
+                -CCD_SETTINGS.NUM_ROWS + image.shape[1],
+                "CCD origin column wrt lower left corner",
+            )
+
+        self.image_header["DATE-OBS"] = (
+            self.timestamp,
+            "Timestamp for 1st frame",
+        )
+        self.image_header["FINETIME"] = (
+            self.finetime,
+            "Finetime representation of DATE-OBS",
+        )
 
         fits.append(str(self._filepath), image, self.image_header)
 
@@ -1209,13 +1358,10 @@ class FITS(PersistenceLayer):
         raise NotImplementedError("Persistence layers must implement a read method")
 
     def update(self, idx, data):
-
         pass
 
     def delete(self, idx):
-
         LOGGER.warning("The delete functionality is not implemented for the CSV persistence layer.")
 
     def get_filepath(self):
-
         return self._filepath