dkist-processing-common 11.7.0rc2__py3-none-any.whl → 11.7.1rc1__py3-none-any.whl

dkist_processing_common/parsers/l1_fits_access.py

@@ -2,12 +2,9 @@
 
 from astropy.io import fits
 
-from dkist_processing_common.models.fits_access import HEADER_KEY_NOT_FOUND
 from dkist_processing_common.models.fits_access import FitsAccessBase
 from dkist_processing_common.models.fits_access import MetadataKey
 
-NOT_A_FLOAT = -999
-
 
 class L1FitsAccess(FitsAccessBase):
     """
@@ -31,48 +28,25 @@ class L1FitsAccess(FitsAccessBase):
     ):
         super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
 
-        self.elevation: float = self.header[MetadataKey.elevation]
-        self.azimuth: float = self.header[MetadataKey.azimuth]
-        self.table_angle: float = self.header[MetadataKey.table_angle]
-        self.gos_level3_status: str = self.header[MetadataKey.gos_level3_status]
-        self.gos_level3_lamp_status: str = self.header[MetadataKey.gos_level3_lamp_status]
-        self.gos_polarizer_status: str = self.header[MetadataKey.gos_polarizer_status]
-        self.gos_retarder_status: str = self.header[MetadataKey.gos_retarder_status]
-        self.gos_level0_status: str = self.header[MetadataKey.gos_level0_status]
-        self.time_obs: str = self.header[MetadataKey.time_obs]
-        self.ip_id: str = self.header[MetadataKey.ip_id]
-        self.instrument: str = self.header[MetadataKey.instrument]
-        self.wavelength: float = self.header[MetadataKey.wavelength]
-        self.proposal_id: str = self.header[MetadataKey.proposal_id]
-        self.experiment_id: str = self.header[MetadataKey.experiment_id]
-        self.num_dsps_repeats: int = self.header[MetadataKey.num_dsps_repeats]
-        self.current_dsps_repeat: int = self.header[MetadataKey.current_dsps_repeat]
-        self.fpa_exposure_time_ms: float = self.header[MetadataKey.fpa_exposure_time_ms]
-        self.sensor_readout_exposure_time_ms: float = self.header[
-            MetadataKey.sensor_readout_exposure_time_ms
-        ]
-        self.num_raw_frames_per_fpa: int = self.header[MetadataKey.num_raw_frames_per_fpa]
-        self.camera_id: str = self.header[MetadataKey.camera_id]
-        self.camera_name: str = self.header[MetadataKey.camera_name]
-        self.camera_bit_depth: int = self.header[MetadataKey.camera_bit_depth]
-        self.hardware_binning_x: int = self.header[MetadataKey.hardware_binning_x]
-        self.hardware_binning_y: int = self.header[MetadataKey.hardware_binning_y]
-        self.software_binning_x: int = self.header[MetadataKey.software_binning_x]
-        self.software_binning_y: int = self.header[MetadataKey.software_binning_y]
-        self.observing_program_execution_id: str = self.header[
-            MetadataKey.observing_program_execution_id
-        ]
-        self.telescope_tracking_mode: str = self.header.get(
-            MetadataKey.telescope_tracking_mode, HEADER_KEY_NOT_FOUND
-        )
-        self.coude_table_tracking_mode: str = self.header.get(
-            MetadataKey.coude_table_tracking_mode, HEADER_KEY_NOT_FOUND
-        )
-        self.telescope_scanning_mode: str = self.header.get(
-            MetadataKey.telescope_scanning_mode, HEADER_KEY_NOT_FOUND
-        )
-        self.light_level: float = self.header[MetadataKey.light_level]
-        self.hls_version: str = self.header[MetadataKey.hls_version]
+        self._set_metadata_key_value(MetadataKey.elevation)
+        self._set_metadata_key_value(MetadataKey.azimuth)
+        self._set_metadata_key_value(MetadataKey.table_angle)
+        self._set_metadata_key_value(MetadataKey.gos_level3_status)
+        self._set_metadata_key_value(MetadataKey.gos_level3_lamp_status)
+        self._set_metadata_key_value(MetadataKey.gos_polarizer_status)
+        self._set_metadata_key_value(MetadataKey.gos_retarder_status)
+        self._set_metadata_key_value(MetadataKey.gos_level0_status)
+        self._set_metadata_key_value(MetadataKey.time_obs)
+        self._set_metadata_key_value(MetadataKey.ip_id)
+        self._set_metadata_key_value(MetadataKey.instrument)
+        self._set_metadata_key_value(MetadataKey.wavelength)
+        self._set_metadata_key_value(MetadataKey.proposal_id)
+        self._set_metadata_key_value(MetadataKey.experiment_id)
+        self._set_metadata_key_value(MetadataKey.num_dsps_repeats)
+        self._set_metadata_key_value(MetadataKey.current_dsps_repeat)
+        self._set_metadata_key_value(MetadataKey.fpa_exposure_time_ms)
+        self._set_metadata_key_value(MetadataKey.sensor_readout_exposure_time_ms)
+        self._set_metadata_key_value(MetadataKey.num_raw_frames_per_fpa)
 
     @property
     def gos_polarizer_angle(self) -> float:
@@ -80,7 +54,7 @@ class L1FitsAccess(FitsAccessBase):
         try:
             return float(self.header[MetadataKey.gos_polarizer_angle])
         except ValueError:
-            return NOT_A_FLOAT  # The angle is only used if the polarizer is in the beam
+            return -999  # The angle is only used if the polarizer is in the beam
 
     @property
     def gos_retarder_angle(self) -> float:
@@ -88,4 +62,4 @@ class L1FitsAccess(FitsAccessBase):
         try:
             return float(self.header[MetadataKey.gos_retarder_angle])
         except ValueError:
-            return NOT_A_FLOAT  # The angle is only used if the retarder is in the beam
+            return -999  # The angle is only used if the retarder is in the beam

dkist_processing_common/parsers/near_bud.py

@@ -66,14 +66,14 @@ class NearFloatBud(Stem):
         -------
         The mean value associated with this input key
         """
-        value_list = list(self.key_to_petal_dict.values())
-        biggest_value = max(value_list)
-        smallest_value = min(value_list)
+        value_set = list(self.key_to_petal_dict.values())
+        biggest_value = max(value_set)
+        smallest_value = min(value_set)
         if biggest_value - smallest_value > self.tolerance:
             raise ValueError(
                 f"{self.stem_name} values are not close enough. Max: {biggest_value}, Min: {smallest_value}, Tolerance: {self.tolerance}"
             )
-        return mean(value_list)
+        return mean(value_set)
 
 
 class TaskNearFloatBud(NearFloatBud):

dkist_processing_common/parsers/proposal_id_bud.py

@@ -2,27 +2,21 @@
 
 from dkist_processing_common.models.constants import BudName
 from dkist_processing_common.models.fits_access import MetadataKey
-from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.id_bud import ContributingIdsBud
-from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
+from dkist_processing_common.parsers.id_bud import IdBud
 
 
-class ProposalIdBud(TaskUniqueBud):
+class ProposalIdBud(IdBud):
     """Class to create a Bud for the proposal_id."""
 
     def __init__(self):
-        super().__init__(
-            constant_name=BudName.proposal_id,
-            metadata_key=MetadataKey.proposal_id,
-            ip_task_types=TaskName.observe,
-        )
+        super().__init__(constant_name=BudName.proposal_id, metadata_key=MetadataKey.proposal_id)
 
 
 class ContributingProposalIdsBud(ContributingIdsBud):
-    """Class to create a Bud for the supporting proposal_ids."""
+    """Class to create a Bud for the proposal_ids."""
 
     def __init__(self):
         super().__init__(
-            constant_name=BudName.contributing_proposal_ids,
-            metadata_key=MetadataKey.proposal_id,
+            stem_name=BudName.contributing_proposal_ids, metadata_key=MetadataKey.proposal_id
         )

dkist_processing_common/parsers/single_value_single_key_flower.py

@@ -2,6 +2,7 @@
 
 from enum import StrEnum
 
+from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.models.flower_pot import Stem
 from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
 

dkist_processing_common/parsers/time.py

@@ -22,6 +22,7 @@ from dkist_processing_common.parsers.single_value_single_key_flower import (
 )
 from dkist_processing_common.parsers.task import passthrough_header_ip_task
 from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
+from dkist_processing_common.parsers.unique_bud import UniqueBud
 
 
 class ObsIpStartTimeBud(TaskUniqueBud):
@@ -35,52 +36,15 @@ class ObsIpStartTimeBud(TaskUniqueBud):
         )
 
 
-class TaskDatetimeBudBase(Stem):
-    """
-    Base class for making datetime-related buds.
-
-    Returns a tuple of sorted values converted from datetimes to unix seconds.
-
-    Complicated parsing of the header into a task type can be achieved by passing in a different
-    header task parsing function.
-
-    Parameters
-    ----------
-    stem_name
-        The name for the constant to be defined
-
-    metadata_key
-        The metadata key associated with the constant
-
-    ip_task_types
-        Only consider objects whose parsed header IP task type matches a string in this list
-
-    header_type_parsing_func
-        The function used to convert a header into an IP task type
-    """
-
-    key_to_petal_dict: dict[str, float]
-
-    def __init__(
-        self,
-        stem_name: str,
-        metadata_key: str | StrEnum,
-        ip_task_types: str | list[str],
-        header_task_parsing_func: Callable = passthrough_header_ip_task,
-    ):
-        super().__init__(stem_name=stem_name)
+class CadenceBudBase(UniqueBud):
+    """Base class for all Cadence Buds."""
 
-        if isinstance(metadata_key, StrEnum):
-            metadata_key = metadata_key.name
-        self.metadata_key = metadata_key
-        if isinstance(ip_task_types, str):
-            ip_task_types = [ip_task_types]
-        self.ip_task_types = [task.casefold() for task in ip_task_types]
-        self.header_parsing_function = header_task_parsing_func
+    def __init__(self, constant_name: str):
+        super().__init__(constant_name, metadata_key=MetadataKey.time_obs)
 
     def setter(self, fits_obj: L0FitsAccess) -> float | Type[SpilledDirt]:
         """
-        Store the metadata key datetime value as unix seconds if the task type is in the desired types.
+        If the file is an observe file, its DATE-OBS value is stored as unix seconds.
 
         Parameters
         ----------
@@ -88,45 +52,16 @@ class TaskDatetimeBudBase(Stem):
             The input fits object
         Returns
         -------
-        The datetime in seconds
+        The observe time in seconds
         """
-        task = self.header_parsing_function(fits_obj)
-
-        if task.casefold() in self.ip_task_types:
+        if fits_obj.ip_task_type.casefold() == TaskName.observe.value.casefold():
             return (
                 datetime.fromisoformat(getattr(fits_obj, self.metadata_key))
                 .replace(tzinfo=timezone.utc)
                 .timestamp()
             )
-
         return SpilledDirt
 
-    def getter(self, key: Hashable) -> tuple[float, ...]:
-        """
-        Return a tuple of sorted times in unix seconds.
-
-        Parameters
-        ----------
-        key
-            The input key
-
-        Returns
-        -------
-        A tuple that is sorted times in unix seconds
-        """
-        return tuple(sorted(list(self.key_to_petal_dict.values())))
-
-
-class CadenceBudBase(TaskDatetimeBudBase):
-    """Base class for all Cadence Buds."""
-
-    def __init__(self, constant_name: str):
-        super().__init__(
-            stem_name=constant_name,
-            metadata_key=MetadataKey.time_obs,
-            ip_task_types=TaskName.observe,
-        )
-
 
 class AverageCadenceBud(CadenceBudBase):
     """Class for the average cadence Bud."""
@@ -147,7 +82,7 @@ class AverageCadenceBud(CadenceBudBase):
         -------
         The mean value of the cadences of the input frames
         """
-        return np.mean(np.diff(super().getter(key)))
+        return np.mean(np.diff(sorted(list(self.key_to_petal_dict.values()))))
 
 
 class MaximumCadenceBud(CadenceBudBase):
@@ -169,7 +104,7 @@ class MaximumCadenceBud(CadenceBudBase):
         -------
         The maximum cadence between frames
         """
-        return np.max(np.diff(super().getter(key)))
+        return np.max(np.diff(sorted(list(self.key_to_petal_dict.values()))))
 
 
 class MinimumCadenceBud(CadenceBudBase):
@@ -191,7 +126,7 @@ class MinimumCadenceBud(CadenceBudBase):
         -------
         The minimum cadence between frames
         """
-        return np.min(np.diff(super().getter(key)))
+        return np.min(np.diff(sorted(list(self.key_to_petal_dict.values()))))
 
 
 class VarianceCadenceBud(CadenceBudBase):
@@ -212,38 +147,11 @@ class VarianceCadenceBud(CadenceBudBase):
         -------
         Return the variance of the cadences over the input frames
         """
-        return np.var(np.diff(super().getter(key)))
-
+        return np.var(np.diff(sorted(list(self.key_to_petal_dict.values()))))
 
-class TaskDateBeginBud(TaskDatetimeBudBase):
-    """Class for the date begin task Bud."""
 
-    def __init__(self, constant_name: str, ip_task_types: str | list[str]):
-        super().__init__(
-            stem_name=constant_name,
-            metadata_key=MetadataKey.time_obs,
-            ip_task_types=ip_task_types,
-        )
-
-    def getter(self, key) -> str:
-        """
-        Return the earliest date begin for the ip task type converted from unix seconds to datetime string.
-
-        Parameters
-        ----------
-        key
-            The input key
-        Returns
-        -------
-        Return the minimum date begin as a datetime string
-        """
-        min_time = super().getter(key)[0]
-        min_time_dt = datetime.fromtimestamp(min_time, tz=timezone.utc)
-        return min_time_dt.strftime("%Y-%m-%dT%H:%M:%S.%f")
-
-
-class RoundTimeFlowerBase(SingleValueSingleKeyFlower):
-    """Base flower for SingleValueSingleKeyFlowers that need to round their values to avoid value jitter."""
+class TimeFlowerBase(SingleValueSingleKeyFlower):
+    """Base task for SingleValueSingleKeyFlowers that need to round their values to avoid value jitter."""
 
     def setter(self, fits_obj: L0FitsAccess):
         """
@@ -261,7 +169,7 @@ class RoundTimeFlowerBase(SingleValueSingleKeyFlower):
         return round(raw_value, EXP_TIME_ROUND_DIGITS)
 
 
-class ExposureTimeFlower(RoundTimeFlowerBase):
+class ExposureTimeFlower(TimeFlowerBase):
     """For tagging the frame FPA exposure time."""
 
     def __init__(self):
@@ -270,7 +178,7 @@ class ExposureTimeFlower(RoundTimeFlowerBase):
         )
 
 
-class ReadoutExpTimeFlower(RoundTimeFlowerBase):
+class ReadoutExpTimeFlower(TimeFlowerBase):
     """For tagging the exposure time of each readout that contributes to an FPA."""
 
     def __init__(self):
@@ -280,18 +188,18 @@ class ReadoutExpTimeFlower(RoundTimeFlowerBase):
         )
 
 
-class TaskRoundTimeBudBase(Stem):
+class TaskTimeBudBase(Stem):
     """
-    Base class for making buds that need a set of rounded times for computing for specific task types.
+    Base class for making time-related buds that are computed for specific task types.
 
-    Metadata key values are already floats.  Returns tuple of sorted unique rounded values.
+    By "time-related" we mean values that generally need rounding when ingested into the database.
 
     Complicated parsing of the header into a task type can be achieved by passing in a different
     header task parsing function.
 
     Parameters
     ----------
-    stem_name
+    constant_name
         The name for the constant to be defined
 
     metadata_key
@@ -304,8 +212,6 @@ class TaskRoundTimeBudBase(Stem):
         The function used to convert a header into an IP task type
     """
 
-    key_to_petal_dict: dict[str, float]
-
     def __init__(
         self,
         stem_name: str,
@@ -323,18 +229,8 @@ class TaskRoundTimeBudBase(Stem):
         self.ip_task_types = [task.casefold() for task in ip_task_types]
         self.header_parsing_function = header_task_parsing_func
 
-    def setter(self, fits_obj: L0FitsAccess) -> float | Type[SpilledDirt]:
-        """
-        Store the metadata key value if the parsed task type is in the desired types.
-
-        Parameters
-        ----------
-        fits_obj
-            The input fits object
-        Returns
-        -------
-        The rounded time
-        """
+    def setter(self, fits_obj: L0FitsAccess):
+        """Return the desired metadata key only if the parsed task type matches the Bud's task type."""
         task = self.header_parsing_function(fits_obj)
 
         if task.casefold() in self.ip_task_types:
@@ -344,22 +240,12 @@ class TaskRoundTimeBudBase(Stem):
         return SpilledDirt
 
     def getter(self, key: Hashable) -> tuple[float, ...]:
-        """
-        Return a tuple of the sorted unique values found.
-
-        Parameters
-        ----------
-        key
-            The input key
-
-        Returns
-        -------
-        A tuple that is the sorted set of unique times
-        """
-        return tuple(sorted(set(self.key_to_petal_dict.values())))
+        """Return a tuple of all the unique values found."""
+        value_tuple = tuple(sorted(set(self.key_to_petal_dict.values())))
+        return value_tuple
 
 
-class TaskExposureTimesBud(TaskRoundTimeBudBase):
+class TaskExposureTimesBud(TaskTimeBudBase):
     """Produce a tuple of all FPA exposure times present in the dataset for a specific ip task type."""
 
     def __init__(
@@ -376,7 +262,7 @@ class TaskExposureTimesBud(TaskRoundTimeBudBase):
         )
 
 
-class TaskReadoutExpTimesBud(TaskRoundTimeBudBase):
+class TaskReadoutExpTimesBud(TaskTimeBudBase):
     """Produce a tuple of all sensor readout exposure times present in the dataset for a specific task type."""
 
     def __init__(

dkist_processing_common/tasks/mixin/quality/_metrics.py

@@ -1356,15 +1356,13 @@ class _WavecalQualityMixin:
         Note that the residuals are the *unweighed* residuals.
         """
         weight_data = np.ones(input_wavelength.size) if weights is None else weights
-        prepared_weights = np.sqrt(weight_data / np.sum(weight_data))
+        prepared_weights = fit_result.prepared_weights
         residuals = fit_result.minimizer_result.residual / prepared_weights
         residuals[~np.isfinite(residuals)] = 0.0
-        best_fit_atlas = input_spectrum - residuals
         normalized_residuals = residuals / input_spectrum
 
-        best_fit_header = fit_result.wavelength_parameters.to_header(axis_num=1)
-        wcs = WCS(best_fit_header)
-        best_fit_wavelength = wcs.spectral.pixel_to_world(np.arange(input_spectrum.size))
+        best_fit_atlas = fit_result.best_fit_atlas
+        best_fit_wavelength = fit_result.best_fit_wavelength_vector
 
         finite_idx = (
             np.isfinite(input_wavelength)
@@ -1378,7 +1376,7 @@ class _WavecalQualityMixin:
         data = {
             "input_wavelength_nm": input_wavelength.to_value(u.nm)[finite_idx].tolist(),
             "input_spectrum": input_spectrum[finite_idx].tolist(),
-            "best_fit_wavelength_nm": best_fit_wavelength.to_value(u.nm)[finite_idx].tolist(),
+            "best_fit_wavelength_nm": best_fit_wavelength[finite_idx].tolist(),
             "best_fit_atlas": best_fit_atlas[finite_idx].tolist(),
             "normalized_residuals": normalized_residuals[finite_idx].tolist(),
             "weights": None if weights is None else weight_data[finite_idx].tolist(),