dkist-processing-dlnirsp 0.14.3__py3-none-any.whl

dkist_processing_dlnirsp/__init__.py

@@ -0,0 +1,9 @@
+"""Package providing support classes and methods used by all workflow tasks."""
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version
+
+try:
+    __version__ = version(distribution_name=__name__)
+except PackageNotFoundError:
+    # package is not installed
+    __version__ = "unknown"

dkist_processing_dlnirsp/config.py

@@ -0,0 +1,12 @@
+"""Configuration for the dkist-processing-dlnirsp package and logging thereof."""
+from dkist_processing_common.config import DKISTProcessingCommonConfiguration
+
+
+class DKISTProcessingDLNIRSPConfigurations(DKISTProcessingCommonConfiguration):
+    """Configurations custom to the dkist-processing-dlnirsp package."""
+
+    pass  # nothing custom.... yet
+
+
+dkist_processing_dlnirsp_configurations = DKISTProcessingDLNIRSPConfigurations()
+dkist_processing_dlnirsp_configurations.log_configurations()

dkist_processing_dlnirsp/dev_scripts/__init__.py

@@ -0,0 +1 @@
+"""Modules to allow easy testing of pipeline components by pipeline developers."""

dkist_processing_dlnirsp/dev_scripts/test_slitbeam_group_assignment.py

@@ -0,0 +1,118 @@
+"""Script for showing the slitbeam assignment based on a group_id array."""
+from collections import defaultdict
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+from astropy.io import fits
+from dkist_processing_common.tasks import WorkflowTaskBase
+from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetParameterValue
+from dkist_service_configuration.logging import logger
+
+from dkist_processing_dlnirsp.models.parameters import DlnirspParameters
+from dkist_processing_dlnirsp.tasks.mixin.group_id import GroupIdMixin
+
+
+class BlankTaskWithGroupId(WorkflowTaskBase, GroupIdMixin):
+    """We just need this so we can use the group id mixin"""
+
+    def run(self) -> None:
+        pass
+
+
+def mark_slitbeams(task: BlankTaskWithGroupId) -> np.ndarray:
+    """Produce an array where each pixel's value is its slitbeam ID."""
+    group_id_array = task.group_id_drifted_id_array
+    slitbeam_group_dict = task.group_id_slitbeam_group_dict
+
+    slitbeam_id_array = np.empty(group_id_array.shape) * np.nan
+    for slitbeam, groups_in_slitbeam in slitbeam_group_dict.items():
+        for group_id in groups_in_slitbeam:
+            group_idx = task.group_id_get_idx(group_id=group_id)
+            slitbeam_id_array[group_idx] = slitbeam
+
+    return slitbeam_id_array
+
+
+def create_parameter_dict(
+    group_id_file_path: str | Path, slit_separation_px: int, arm_id: str
+) -> dict[str, list[InputDatasetParameterValue]]:
+    """Create a dictionary that can be used to instantiate a DlnirspParameters object."""
+    param_dict = defaultdict(list)
+    date = datetime(1946, 11, 20)
+    param_dict["dlnirsp_group_id_rough_slit_separation_px"].append(
+        InputDatasetParameterValue(
+            parameter_value=slit_separation_px,
+            parameter_value_id=0,
+            parameter_value_start_date=date,
+        )
+    )
+    file_param_dict = {"param_path": str(group_id_file_path.absolute()), "is_file": True}
+    param_dict[f"dlnirsp_group_id_file_{arm_id.casefold()}"].append(
+        InputDatasetParameterValue(
+            parameter_value=file_param_dict, parameter_value_id=1, parameter_value_start_date=date
+        )
+    )
+
+    return param_dict
+
+
+def main(
+    group_id_file_path: str | Path,
+    output_file_name: str,
+    arm_id: str,
+    rough_slit_separation_px: int = 300,
+) -> int:
+    """Use provided group id file to make a slitbeam id file."""
+    if isinstance(group_id_file_path, str):
+        group_id_file_path = Path(group_id_file_path)
+
+    logger.info("Setting up task and parameters")
+    task = BlankTaskWithGroupId(
+        recipe_run_id=0, workflow_name="test_group_id_assignment", workflow_version="0.0.0b1rc0"
+    )
+
+    loaded_parameter_dict = create_parameter_dict(
+        group_id_file_path, rough_slit_separation_px, arm_id=arm_id
+    )
+    task.parameters = DlnirspParameters(
+        loaded_parameter_dict, wavelength=1.0, arm_id=arm_id
+    )  # Wavelength doesn't matter
+
+    logger.info("Creating slitbeam id array")
+    slitbeam_array = mark_slitbeams(task)
+
+    fits.PrimaryHDU(slitbeam_array).writeto(output_file_name, overwrite=True)
+    logger.info(f"Slitbeam id array saved to {output_file_name}")
+
+    return 0
+
+
+def command_line():
+    """Entry point for main() from command line."""
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(
+        description="Produce a FITS file showing the slitbeam each pixel is assigned to."
+    )
+    parser.add_argument(
+        "-s",
+        "--slit-separation-px",
+        help="Rough distance between 2 DL slits (NOT slitbeams)",
+        type=int,
+        default=300,
+    )
+    parser.add_argument("-a", "--arm-id", help="Dlnirsp arm", type=str, default="JBand")
+    parser.add_argument("group_id_file", help="Path to a group_id FITS file")
+    parser.add_argument("output_file", help="Where to save slitbeam assignment file")
+
+    args = parser.parse_args()
+    sys.exit(
+        main(
+            group_id_file_path=args.group_id_file,
+            output_file_name=args.output_file,
+            rough_slit_separation_px=args.slit_separation_px,
+            arm_id=args.arm_id,
+        )
+    )

dkist_processing_dlnirsp/models/__init__.py

@@ -0,0 +1 @@
+"""Data classifications and enumerations."""

dkist_processing_dlnirsp/models/constants.py

@@ -0,0 +1,154 @@
+"""Dataset-level constants for a pipeline run."""
+from enum import Enum
+
+from dkist_processing_common.models.constants import BudName
+from dkist_processing_common.models.constants import ConstantsBase
+
+
+class DlnirspBudName(Enum):
+    """Names to be used for DLNIRSP buds."""
+
+    arm_id = "ARM_ID"
+    num_beams = "NUM_BEAMS"
+    num_dsps_repeats = "NUM_DSPS_REPEATS"  # TODO: Maybe we don't need this?
+    num_dither_steps = "NUM_DITHER_STEPS"
+    num_mosaic_repeats = "NUM_MOSAIC_REPEATS"
+    num_spatial_steps_X = "NUM_SPATIAL_STEPS_X"
+    num_spatial_steps_Y = "NUM_SPATIAL_STEPS_Y"
+    num_modstates = "NUM_MODSTATES"
+    wavelength = "WAVELENGTH"
+    camera_readout_mode = "CAMERA_READOUT_MODE"
+    polarimeter_mode = "POLARIMETER_MODE"
+    time_obs_list = "TIME_OBS_LIST"
+    lamp_gain_exposure_times = "LAMP_GAIN_EXPOSURE_TIMES"
+    solar_gain_exposure_times = "SOLAR_GAIN_EXPOSURE_TIMES"
+    polcal_exposure_times = "POLCAL_EXPOSURE_TIMES"
+    observe_exposure_times = "OBSERVE_EXPOSURE_TIMES"
+    non_dark_task_exposure_times = "NON_DARK_TASK_EXPOSURE_TIMES"
+
+
+VIS_ARM_NAMES = ["VIS".casefold()]
+IR_ARM_NAMES = ["JBand".casefold(), "HBand".casefold()]
+
+
+class DlnirspConstants(ConstantsBase):
+    """DLNIRSP specific constants to add to the common constants."""
+
+    @property
+    def arm_id(self) -> str:
+        """Arm used to record the data, either VIS or one of 2 IR bands."""
+        return self._db_dict[DlnirspBudName.arm_id]
+
+    @property
+    def is_ir_data(self) -> bool:
+        """Return True if the data are from an IR camera and need to be linearized."""
+        if self.arm_id.casefold() in VIS_ARM_NAMES:
+            return False
+        if self.arm_id.casefold() in IR_ARM_NAMES:
+            return True
+        raise ValueError(f"Unable to determine the camera type of Arm ID {self.arm_id}")
+
+    @property
+    def num_beams(self) -> int:
+        """Determine the number of beams present in the data."""
+        return 2
+
+    @property
+    def num_slits(self) -> int:
+        """Return the number of slits on a single detector readout."""
+        return 4
+
+    @property
+    def num_dither_steps(self) -> int:
+        """Return the number of dither steps."""
+        return self._db_dict[DlnirspBudName.num_dither_steps]
+
+    @property
+    def num_mosaic_repeats(self) -> int:
+        """
+        Return the number of mosaic repeats.
+
+        I.e., the number of times the mosaic pattern was observed.
+        """
+        return self._db_dict[DlnirspBudName.num_mosaic_repeats]
+
+    @property
+    def num_spatial_steps_X(self) -> int:
+        """Return the number of spatial steps in the X direction in the mosaic pattern."""
+        return self._db_dict[DlnirspBudName.num_spatial_steps_X]
+
+    @property
+    def num_spatial_steps_Y(self) -> int:
+        """Return the number of spatial steps in the Y direction in the mosaic pattern."""
+        return self._db_dict[DlnirspBudName.num_spatial_steps_Y]
+
+    @property
+    def num_mosaic_tiles(self) -> int:
+        """Return the total number of tiles that make up the full mosaic."""
+        return self.num_spatial_steps_X * self.num_spatial_steps_Y
+
+    @property
+    def num_cs_steps(self):
+        """Find the number of calibration sequence steps."""
+        return self._db_dict[BudName.num_cs_steps]
+
+    @property
+    def time_obs_list(self) -> list[str]:
+        """Construct a list of all the dateobs for this dataset."""
+        return self._db_dict[DlnirspBudName.time_obs_list]
+
+    @property
+    def wavelength(self) -> float:
+        """Wavelength."""
+        return self._db_dict[DlnirspBudName.wavelength]
+
+    @property
+    def camera_readout_mode(self) -> str:
+        """Determine the readout mode of the camera."""
+        return self._db_dict[DlnirspBudName.camera_readout_mode]
+
+    @property
+    def correct_for_polarization(self) -> bool:
+        """Return True if dataset is polarimetric."""
+        # TODO: Check what the option "Other" for DLPOLMD means
+        return self._db_dict[DlnirspBudName.polarimeter_mode] == "Full Stokes"
+
+    @property
+    def lamp_gain_exposure_times(self) -> list[float]:
+        """Construct a list of lamp gain FPA exposure times for the dataset."""
+        return self._db_dict[DlnirspBudName.lamp_gain_exposure_times]
+
+    @property
+    def solar_gain_exposure_times(self) -> list[float]:
+        """Construct a list of solar gain FPA exposure times for the dataset."""
+        return self._db_dict[DlnirspBudName.solar_gain_exposure_times]
+
+    @property
+    def polcal_exposure_times(self) -> list[float]:
+        """Construct a list of polcal FPA exposure times for the dataset."""
+        if self.correct_for_polarization:
+            return self._db_dict[DlnirspBudName.polcal_exposure_times]
+        else:
+            return []
+
+    @property
+    def observe_exposure_times(self) -> list[float]:
+        """Construct a list of observe FPA exposure times."""
+        return self._db_dict[DlnirspBudName.observe_exposure_times]
+
+    @property
+    def non_dark_task_exposure_times(self) -> list[float]:
+        """Return a list of all exposure times required for all tasks other than dark."""
+        exposure_times = list()
+        exposure_times.extend(self.lamp_gain_exposure_times)
+        exposure_times.extend(self.solar_gain_exposure_times)
+        exposure_times.extend(self.observe_exposure_times)
+        if self.correct_for_polarization:
+            exposure_times.extend(self.polcal_exposure_times)
+        exposure_times = list(set(exposure_times))
+        return exposure_times
+
+    @property
+    def num_modstates(self) -> int:
+        """Return the number of modulator states."""
+        return self._db_dict[DlnirspBudName.num_modstates]

dkist_processing_dlnirsp/models/parameters.py

@@ -0,0 +1,177 @@
+"""Machinery to access pipeline parameters served in input dataset document."""
+from datetime import datetime
+from functools import cached_property
+
+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
+
+
+class DlnirspParsingParameters(ParameterBase):
+    """
+    Parameters specifically (and only) for the Parse task.
+
+    Needed because the Parse task doesn't know what the wavelength is yet and therefore can't use the
+    `ParameterWaveLengthMixin`.
+    """
+
+    @property
+    def max_cs_step_time_sec(self) -> float:
+        """Time window within which CS steps with identical GOS configurations are considered to be the same."""
+        return self._find_most_recent_past_value(
+            "dlnirsp_max_cs_step_time_sec", start_date=datetime.now()
+        )
+
+
+class DlnirspParameters(ParameterBase, ParameterWavelengthMixin, ParameterArmIdMixin):
+    """Put all DLNIRSP parameters parsed from the input dataset document in a single property."""
+
+    @cached_property
+    def raw_group_id_array(self) -> np.ndarray:
+        """
+        Return an array containing 'group ids' of each array pixel.
+
+        The group id labels each IFU ribbon/mirror slice.
+
+        NOTE: This array has NOT been corrected for IFU drift. See `GroupIdMixin.group_id_drifted_id_array` for that.
+        """
+        param_dict = self._find_parameter_for_arm("dlnirsp_group_id_file")
+        return self._load_param_value_from_fits(param_dict)
+
+    @cached_property
+    def raw_dispersion_array(self) -> np.ndarray:
+        """
+        Return an array that provides the dispersion (in Angstrom / px) for each group.
+
+        NOTE: This array has NOT been corrected for IFU drift. Use the intermediate frame
+        `DlnirspTag.task_drifted_dispersion()` for that.
+        """
+        param_dict = self._find_parameter_for_arm("dlnirsp_geo_dispersion_file")
+        return self._load_param_value_from_fits(param_dict)
+
+    @property
+    def raw_ifu_x_pos_array(self) -> np.ndarray:
+        """
+        Return the array mapping raw pixel position to an X coordinate in the IFU.
+
+        NOTE: This array has NOT been corrected for IFU drift. Use the intermediate frame
+        `DlnirspTag.task_drifted_ifu_x_pos()` for that.
+        """
+        param_dict = self._find_parameter_for_arm("dlnirsp_ifu_x_pos_file")
+        return self._load_param_value_from_fits(param_dict)
+
+    @property
+    def raw_ifu_y_pos_array(self) -> np.ndarray:
+        """
+        Return the array mapping raw pixel position to an X coordinate in the IFU.
+
+        NOTE: This array has NOT been corrected for IFU drift. Use the intermediate frame
+        `DlnirspTag.task_drifted_ifu_y_pos()` for that.
+        """
+        param_dict = self._find_parameter_for_arm("dlnirsp_ifu_y_pos_file")
+        return self._load_param_value_from_fits(param_dict)
+
+    @property
+    def group_id_max_drift_px(self) -> int:
+        """
+        Define the maximum pixel shift allowed when computing group ID drift.
+
+        If the computed drift is larger than this then the raw group ID array will be used.
+        """
+        return self._find_most_recent_past_value("dlnirsp_group_id_max_drift_px")
+
+    @property
+    def group_id_rough_slit_separation_px(self) -> float:
+        """
+        Rough pixel distance between slits.
+
+        This is NOT the pixel distance between both beams of the same slit.
+        """
+        return self._find_most_recent_past_value("dlnirsp_group_id_rough_slit_separation_px")
+
+    @property
+    def corrections_max_nan_frac(self) -> float:
+        """
+        Maximum allowable fraction of NaN in a shifted pixel before that pixel gets converted to NaN.
+
+        Input NaN values are tracked and any shifted pixel that has a value made up of more than this fraction of NaN
+        pixels will be set to NaN.
+        """
+        return self._find_most_recent_past_value("dlnirsp_corrections_max_nan_frac")
+
+    @property
+    def pac_remove_linear_I_trend(self) -> bool:
+        """Flag that determines if a linear intensity trend is removed from the whole PolCal CS.
+
+        The trend is fit using the average flux in the starting and ending clear steps.
+        """
+        return self._find_most_recent_past_value("dlnirsp_pac_remove_linear_I_trend")
+
+    @property
+    def pac_fit_mode(self) -> str:
+        """Name of set of fitting flags to use during PAC Calibration Unit parameter fits."""
+        return self._find_most_recent_past_value("dlnirsp_pac_fit_mode")
+
+    @property
+    def pac_init_set(self):
+        """Name of set of initial values for Calibration Unit parameter fit."""
+        return self._find_most_recent_past_value("dlnirsp_pac_init_set")
+
+    @property
+    def lamp_despike_kernel(self) -> (float, float):
+        """Return the (x, y) stddev of the Gaussian kernel used for lamp despiking."""
+        return self._find_most_recent_past_value("dlnirsp_lamp_despike_kernel")
+
+    @property
+    def lamp_despike_threshold(self) -> float:
+        """Return the threhold value used to identify spikes in lamp gains."""
+        return self._find_most_recent_past_value("dlnirsp_lamp_despike_threshold")
+
+    @property
+    def geo_spectral_edge_trim(self) -> int:
+        """Return the +/- number of pixels to remove from the ends of all spectra prior to fitting."""
+        return self._find_most_recent_past_value("dlnirsp_geo_spectral_edge_trim")
+
+    @property
+    def geo_continuum_smoothing_sigma_px(self) -> float:
+        """
+        Return the Gaussian sigma used to smooth out spectral lines when estimating the continuum background.
+
+        This should be roughly the width, in px, of typical spectral lines. Err on the side of too large.
+        """
+        return self._find_most_recent_past_value("dlnirsp_geo_continuum_smoothing_sigma_px")
+
+    @property
+    def geo_max_shift_px(self) -> float:
+        """
+        Return the maximum shift to consider when computing spectral curvature.
+
+        This is an absolute value: negative and positive shifts are constrained to the same magnitude.
+        """
+        return self._find_most_recent_past_value("dlnirsp_geo_max_shift_px")
+
+    @property
+    def geo_shift_poly_fit_order(self) -> int:
+        """Return the order of the polynomial used to fit spectral shifts as a function of slit position."""
+        return self._find_most_recent_past_value("dlnirsp_geo_shift_poly_fit_order")
+
+    @property
+    def geo_bad_px_sigma_threshold(self) -> float:
+        """Any pixels larger than this many stddevs from a difference between a filtered and raw spectrum will be removed."""
+        return self._find_most_recent_past_value("dlnirsp_geo_bad_px_sigma_threshold")
+
+    @property
+    def geo_slitbeam_fit_sig_clip(self) -> int:
+        """Plus/minus number of standard deviations away from the median used to reject outlier values when fitting along the slitbeams."""
+        return self._find_most_recent_past_value("dlnirsp_geo_slitbeam_fit_sig_clip")
+
+    @property
+    def geo_reference_wave_min_nonnan_frac(self) -> float:
+        """
+        Minimum fraction of non-NaN values allowed in reference wavelength regions.
+
+        Wavelength regions with less than this fraction of non-NaN pixels (across all slitbeams) will be excluded from
+        the reference wavelength vector.
+        """
+        return self._find_most_recent_past_value("dlnirsp_geo_reference_wave_min_nonnan_frac")

dkist_processing_dlnirsp/models/tags.py

@@ -0,0 +1,157 @@
+"""DLNIRSP-specific file tags."""
+from enum import Enum
+
+from dkist_processing_common.models.tags import Tag
+
+from dkist_processing_dlnirsp.models.task_name import DlnirspTaskName
+
+
+class DlnirspStemName(str, Enum):
+    """Controlled list of Tag Stems."""
+
+    linearized = "LINEARIZED"
+    beam = "BEAM"
+    arm_id = "ARM_ID"
+    scan_step = "SCAN_STEP"
+    current_frame_in_ramp = "CURRENT_FRAME_IN_RAMP"
+    time_obs = "TIME_OBS"
+    modstate = "MODSTATE"
+    dither_step = "DITHER_STEP"
+    mosaic_num = "MOSAIC_NUM"
+    tile_X_num = "TILE_X_NUM"
+    tile_Y_num = "TILE_Y_NUM"
+
+
+class DlnirspTag(Tag):
+    """DLNIRSP specific tag formatting."""
+
+    @classmethod
+    def beam(cls, beam_num: int) -> str:
+        """
+        Tags by beam number.
+
+        Parameters
+        ----------
+        beam_num
+            The beam number
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(DlnirspStemName.beam, beam_num)
+
+    @classmethod
+    def modstate(cls, modstate: int) -> str:
+        """
+        Tags by the current modstate number.
+
+        Parameters
+        ----------
+        modstate
+            The current scan step number
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(DlnirspStemName.modstate, modstate)
+
+    @classmethod
+    def linearized(cls) -> str:
+        """
+        Tags for linearized frames.
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(DlnirspStemName.linearized)
+
+    @classmethod
+    def arm_id(cls, arm_id: str) -> str:
+        """
+        Tags based on the CryoNIRSP arm_id from which the data is recorded (SP or CI).
+
+        Parameters
+        ----------
+        arm_id
+            The arm ID in use, SP or CI
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(DlnirspStemName.arm_id, arm_id)
+
+    @classmethod
+    def current_frame_in_ramp(cls, curr_frame_in_ramp: int) -> str:
+        """
+        Tags based on the current frame number in the ramp.
+
+        Parameters
+        ----------
+        curr_frame_in_ramp
+            The current frame number for this ramp
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(DlnirspStemName.current_frame_in_ramp, curr_frame_in_ramp)
+
+    @classmethod
+    def time_obs(cls, time_obs: str) -> str:
+        """
+        Tags by the observe date.
+
+        Parameters
+        ----------
+        time_obs
+            The observe time
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(DlnirspStemName.time_obs, time_obs)
+
+    @classmethod
+    def mosaic_num(cls, mosaic_num: int) -> str:
+        """Tags by the mosaic number."""
+        return cls.format_tag(DlnirspStemName.mosaic_num, mosaic_num)
+
+    @classmethod
+    def tile_X_num(cls, tile_X_num: int) -> str:
+        """Tags by the current mosaic location in the X direction."""
+        return cls.format_tag(DlnirspStemName.tile_X_num, tile_X_num)
+
+    @classmethod
+    def tile_Y_num(cls, tile_Y_num: int) -> str:
+        """Tags by the current mosaic location in the Y direction."""
+        return cls.format_tag(DlnirspStemName.tile_Y_num, tile_Y_num)
+
+    @classmethod
+    def dither_step(cls, dither_step: int) -> str:
+        """Tags by dither step."""
+        return cls.format_tag(DlnirspStemName.dither_step, dither_step)
+
+    @classmethod
+    def task_drifted_ifu_groups(cls) -> str:
+        """Identify the IFU group ID array with drift applied."""
+        return cls.task(DlnirspTaskName.drifted_ifu_group_id)
+
+    @classmethod
+    def task_drifted_dispersion(cls) -> str:
+        """Identify the IFU dispersion array with drift applied."""
+        return cls.task(DlnirspTaskName.drifted_dispersion)
+
+    @classmethod
+    def task_drifted_ifu_x_pos(cls) -> str:
+        """Identify the IFU X Pos array with drift applied."""
+        return cls.task(DlnirspTaskName.drifted_ifu_x_pos)
+
+    @classmethod
+    def task_drifted_ifu_y_pos(cls) -> str:
+        """Identify the IFU Y Pos array with drift applied."""
+        return cls.task(DlnirspTaskName.drifted_ifu_y_pos)

dkist_processing_dlnirsp/models/task_name.py

@@ -0,0 +1,11 @@
+"""List of intermediate task names."""
+from enum import StrEnum
+
+
+class DlnirspTaskName(StrEnum):
+    """Controlled list of DLNIRSP task tag names."""
+
+    drifted_ifu_group_id = "DRIFTED_IFU_GROUP_ID"
+    drifted_dispersion = "DRIFTED_DISPERSION"
+    drifted_ifu_x_pos = "DRIFTED_IFU_XPOS"
+    drifted_ifu_y_pos = "DRIFTED_IFU_YPOS"

dkist_processing_dlnirsp/parsers/__init__.py

@@ -0,0 +1 @@
+"""Tools to read dataset and ingest metadata required for science processing."""