dkist-processing-common 11.7.0rc3__tar.gz → 11.7.1rc1__tar.gz

{dkist_processing_common-11.7.0rc3 → dkist_processing_common-11.7.1rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-common
-Version: 11.7.0rc3
+Version: 11.7.1rc1
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause
@@ -21,7 +21,7 @@ Requires-Dist: dkist-processing-core==6.0.0
 Requires-Dist: dkist-processing-pac<4.0,>=3.1
 Requires-Dist: dkist-service-configuration<5.0,>=4.1.7
 Requires-Dist: dkist-spectral-lines<4.0,>=3.0.0
-Requires-Dist: solar-wavelength-calibration<2.0,>=1.0
+Requires-Dist: solar-wavelength-calibration<3.0,>=2.0.0rc1
 Requires-Dist: globus-sdk>=3.12.0
 Requires-Dist: gqlclient[pydantic]==1.2.3
 Requires-Dist: sqids==0.5.1

dkist_processing_common-11.7.1rc1/changelog/271.misc.rst

@@ -0,0 +1 @@
+Move `solar-wavelength-calibration` dep to 2.0.0 and make use of new helper properties in that release.

dkist_processing_common-11.7.1rc1/dkist_processing_common/models/constants.py

@@ -0,0 +1,187 @@
+"""
+Components of the Constant model.
+
+Contains names of database entries and Base class for an object that simplifies
+accessing the database (tab completion, etc.)
+"""
+
+from enum import StrEnum
+from string import ascii_uppercase
+
+from sqids import Sqids
+
+from dkist_processing_common._util.constants import ConstantsDb
+
+
+class BudName(StrEnum):
+    """Controlled list of names for constant stems (buds)."""
+
+    instrument = "INSTRUMENT"
+    num_cs_steps = "NUM_CS_STEPS"
+    num_modstates = "NUM_MODSTATES"
+    retarder_name = "RETARDER_NAME"
+    proposal_id = "PROPOSAL_ID"
+    contributing_proposal_ids = "CONTRIBUTING_PROPOSAL_IDS"
+    experiment_id = "EXPERIMENT_ID"
+    contributing_experiment_ids = "CONTRIBUTING_EXPERIMENT_IDS"
+    obs_ip_start_time = "OBS_IP_START_TIME"
+    average_cadence = "AVERAGE_CADENCE"
+    maximum_cadence = "MAXIMUM_CADENCE"
+    minimum_cadence = "MINIMUM_CADENCE"
+    variance_cadence = "VARIANCE_CADENCE"
+    num_dsps_repeats = "NUM_DSPS_REPEATS"
+    dark_exposure_times = "DARK_EXPOSURE_TIMES"
+    dark_readout_exp_times = "DARK_READOUT_EXP_TIMES"
+    wavelength = "WAVELENGTH"
+
+
+class ConstantsBase:
+    """
+    Aggregate (from the constant buds flower pot) in a single property on task classes.
+
+    It also provides some default constants, but is intended to be subclassed by instruments.
+
+    To subclass:
+
+    1. Create the actual subclass. All you need to do is add more @properties for the constants you want
+
+    2. Update the instrument class's `constants_model_class` property to return the new subclass. For example::
+
+         class NewConstants(ConstantsBase):
+            @property
+            def something(self):
+                return 7
+
+         class InstrumentWorkflowTask(WorkflowTaskBase):
+            @property
+            def constants_model_class:
+                return NewConstants
+
+            ...
+
+    Parameters
+    ----------
+    recipe_run_id
+        The recipe_run_id
+    task_name
+        The task_name
+    """
+
+    def __init__(self, recipe_run_id: int, task_name: str):
+        self._db_dict = ConstantsDb(recipe_run_id=recipe_run_id, task_name=task_name)
+        self._recipe_run_id = recipe_run_id
+
+    # These management functions are all underscored because we want tab-complete to *only* show the available
+    #  constants
+    def _update(self, d: dict):
+        self._db_dict.update(d)
+
+    def _purge(self):
+        self._db_dict.purge()
+
+    def _close(self):
+        self._db_dict.close()
+
+    def _rollback(self):
+        self._db_dict.rollback()
+
+    @property
+    def dataset_id(self) -> str:
+        """Define the dataset_id constant."""
+        return Sqids(min_length=6, alphabet=ascii_uppercase).encode([self._recipe_run_id])
+
+    @property
+    def stokes_params(self) -> [str]:
+        """Return the list of stokes parameter names."""
+        return ["I", "Q", "U", "V"]
+
+    @property
+    def instrument(self) -> str:
+        """Get the instrument name."""
+        return self._db_dict[BudName.instrument]
+
+    @property
+    def num_cs_steps(self):
+        """Get the number of calibration sequence steps."""
+        return self._db_dict[BudName.num_cs_steps]
+
+    @property
+    def num_modstates(self):
+        """Get the number of modulation states."""
+        return self._db_dict[BudName.num_modstates]
+
+    @property
+    def retarder_name(self):
+        """Get the retarder name."""
+        return self._db_dict[BudName.retarder_name]
+
+    @property
+    def proposal_id(self) -> str:
+        """Get the proposal_id constant."""
+        return self._db_dict[BudName.proposal_id]
+
+    @property
+    def contributing_proposal_ids(self) -> [str]:
+        """Return the list of contributing proposal IDs."""
+        proposal_ids = self._db_dict[BudName.contributing_proposal_ids]
+        if isinstance(proposal_ids, str):
+            return [proposal_ids]
+        return proposal_ids
+
+    @property
+    def experiment_id(self) -> str:
+        """Get the experiment_id constant."""
+        return self._db_dict[BudName.experiment_id]
+
+    @property
+    def contributing_experiment_ids(self) -> [str]:
+        """Return the list of contributing experiment IDs."""
+        experiment_ids = self._db_dict[BudName.contributing_experiment_ids]
+        if isinstance(experiment_ids, str):
+            return [experiment_ids]
+        return experiment_ids
+
+    @property
+    def obs_ip_start_time(self) -> str:
+        """Return the start time of the observe IP."""
+        return self._db_dict[BudName.obs_ip_start_time]
+
+    @property
+    def average_cadence(self) -> float:
+        """Get the average_cadence constant."""
+        return self._db_dict[BudName.average_cadence]
+
+    @property
+    def maximum_cadence(self) -> float:
+        """Get the maximum cadence constant constant."""
+        return self._db_dict[BudName.maximum_cadence]
+
+    @property
+    def minimum_cadence(self) -> float:
+        """Get the minimum cadence constant constant."""
+        return self._db_dict[BudName.minimum_cadence]
+
+    @property
+    def variance_cadence(self) -> float:
+        """Get the variance of the cadence constant."""
+        return self._db_dict[BudName.variance_cadence]
+
+    @property
+    def num_dsps_repeats(self) -> int:
+        """Get the number of dsps repeats."""
+        return self._db_dict[BudName.num_dsps_repeats]
+
+    @property
+    def dark_exposure_times(self) -> [float]:
+        """Get a list of exposure times used in the dark calibration."""
+        return self._db_dict[BudName.dark_exposure_times]
+
+    @property
+    def dark_readout_exp_times(self) -> [float]:
+        """Get a list of readout exp times for all DARK frames."""
+        return self._db_dict[BudName.dark_readout_exp_times]
+
+    @property
+    def wavelength(self) -> float:
+        """Wavelength."""
+        return self._db_dict[BudName.wavelength]

{dkist_processing_common-11.7.0rc3 → dkist_processing_common-11.7.1rc1}/dkist_processing_common/models/fits_access.py

@@ -3,16 +3,15 @@
 from __future__ import annotations
 
 from enum import StrEnum
-from enum import unique
 from pathlib import Path
+from typing import Any
 
 import numpy as np
 from astropy.io import fits
 
-HEADER_KEY_NOT_FOUND = "HEADER_KEY_NOT_FOUND"
+NOT_FOUND_MESSAGE = "_HEADER_KEYWORD_NOT_FOUND"
 
 
-@unique
 class MetadataKey(StrEnum):
     """Controlled list of names for FITS metadata header keys."""
 
@@ -40,19 +39,6 @@ class MetadataKey(StrEnum):
     fpa_exposure_time_ms = "XPOSURE"
     sensor_readout_exposure_time_ms = "TEXPOSUR"
     num_raw_frames_per_fpa = "NSUMEXP"
-    camera_id = "CAM_ID"
-    camera_name = "CAMERA"
-    camera_bit_depth = "BITDEPTH"
-    hardware_binning_x = "HWBIN1"
-    hardware_binning_y = "HWBIN2"
-    software_binning_x = "SWBIN1"
-    software_binning_y = "SWBIN2"
-    observing_program_execution_id = "OBSPR_ID"
-    telescope_tracking_mode = "TELTRACK"
-    coude_table_tracking_mode = "TTBLTRCK"
-    telescope_scanning_mode = "TELSCAN"
-    light_level = "LIGHTLVL"
-    hls_version = "HLSVERS"
 
 
 class FitsAccessBase:
@@ -82,6 +68,29 @@ class FitsAccessBase:
     def __repr__(self):
         return f"{self.__class__.__name__}(hdu={self._hdu!r}, name={self.name!r}, auto_squeeze={self.auto_squeeze})"
 
+    def _set_metadata_key_value(
+        self, key: StrEnum, optional: bool = False, default: Any = NOT_FOUND_MESSAGE
+    ) -> None:
+        """
+        Get the header value and assign it as a metadata key name attribute.
+
+        Parameters
+        ----------
+        key
+            The StrEnum member in attribute_name = fits_keyword structure
+        optional
+            If the keyword is optional
+        default
+            Value for the attribute if the key is not found
+        """
+        if optional:
+            if default != NOT_FOUND_MESSAGE:
+                setattr(self, key.name, self.header.get(key, default))
+            else:
+                setattr(self, key.name, self.header.get(key, key + NOT_FOUND_MESSAGE))
+        else:
+            setattr(self, key.name, self.header[key])
+
     @property
     def data(self) -> np.ndarray:
         """

{dkist_processing_common-11.7.0rc3 → dkist_processing_common-11.7.1rc1}/dkist_processing_common/parsers/experiment_id_bud.py

@@ -2,19 +2,16 @@
 
 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 ExperimentIdBud(TaskUniqueBud):
+class ExperimentIdBud(IdBud):
     """Class to create a Bud for the experiment_id."""
 
     def __init__(self):
         super().__init__(
-            constant_name=BudName.experiment_id,
-            metadata_key=MetadataKey.experiment_id,
-            ip_task_types=TaskName.observe,
+            constant_name=BudName.experiment_id, metadata_key=MetadataKey.experiment_id
         )
 
 
@@ -23,6 +20,5 @@ class ContributingExperimentIdsBud(ContributingIdsBud):
 
     def __init__(self):
         super().__init__(
-            constant_name=BudName.contributing_experiment_ids,
-            metadata_key=MetadataKey.experiment_id,
+            stem_name=BudName.contributing_experiment_ids, metadata_key=MetadataKey.experiment_id
         )

dkist_processing_common-11.7.1rc1/dkist_processing_common/parsers/id_bud.py

@@ -0,0 +1,60 @@
+"""Base classes for ID bud parsing."""
+
+from enum import StrEnum
+from typing import Type
+
+from dkist_processing_common.models.flower_pot import SpilledDirt
+from dkist_processing_common.models.flower_pot import Stem
+from dkist_processing_common.models.task_name import TaskName
+from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
+from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
+
+
+class IdBud(TaskUniqueBud):
+    """Base class for ID buds."""
+
+    def __init__(self, constant_name: str, metadata_key: str | StrEnum):
+        super().__init__(
+            constant_name=constant_name,
+            metadata_key=metadata_key,
+            ip_task_types=TaskName.observe,
+        )
+
+
+class ContributingIdsBud(Stem):
+    """Base class for contributing ID buds."""
+
+    def __init__(self, stem_name: str, metadata_key: str | StrEnum):
+        super().__init__(stem_name=stem_name)
+        if isinstance(metadata_key, StrEnum):
+            metadata_key = metadata_key.name
+        self.metadata_key = metadata_key
+
+    def setter(self, fits_obj: L0FitsAccess) -> str | Type[SpilledDirt]:
+        """
+        Set the id for any type of frame.
+
+        Parameters
+        ----------
+        fits_obj
+            The input fits object
+        Returns
+        -------
+        The id
+        """
+        return getattr(fits_obj, self.metadata_key)
+
+    def getter(self, key) -> tuple:
+        """
+        Get all ids seen in non observe frames.
+
+        Parameters
+        ----------
+        key
+            The input key
+
+        Returns
+        -------
+        IDs from non observe frames
+        """
+        return tuple(set(self.key_to_petal_dict.values()))

{dkist_processing_common-11.7.0rc3 → dkist_processing_common-11.7.1rc1}/dkist_processing_common/parsers/l0_fits_access.py

@@ -27,6 +27,6 @@ class L0FitsAccess(L1FitsAccess):
         auto_squeeze: bool = True,
     ):
         super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
-        self.ip_task_type: str = self.header[MetadataKey.ip_task_type]
-        self.ip_start_time: str = self.header[MetadataKey.ip_start_time]
-        self.ip_end_time: str = self.header[MetadataKey.ip_end_time]
+        self._set_metadata_key_value(MetadataKey.ip_task_type)
+        self._set_metadata_key_value(MetadataKey.ip_start_time)
+        self._set_metadata_key_value(MetadataKey.ip_end_time)

dkist_processing_common-11.7.1rc1/dkist_processing_common/parsers/l1_fits_access.py

@@ -0,0 +1,65 @@
+"""By-frame 214 L1 only header keywords that are not instrument specific."""
+
+from astropy.io import fits
+
+from dkist_processing_common.models.fits_access import FitsAccessBase
+from dkist_processing_common.models.fits_access import MetadataKey
+
+
+class L1FitsAccess(FitsAccessBase):
+    """
+    Class defining a fits access object for processed L1 data.
+
+    Parameters
+    ----------
+    hdu
+        The input fits hdu
+    name
+        An optional name to be associated with the hdu
+    auto_squeeze
+        A boolean indicating whether to 'squeeze' out dimensions of size 1
+    """
+
+    def __init__(
+        self,
+        hdu: fits.ImageHDU | fits.PrimaryHDU | fits.CompImageHDU,
+        name: str | None = None,
+        auto_squeeze: bool = False,  # Because L1 data should always have the right form, right?
+    ):
+        super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
+
+        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:
+        """Convert the polarizer angle to a float if possible before returning."""
+        try:
+            return float(self.header[MetadataKey.gos_polarizer_angle])
+        except ValueError:
+            return -999  # The angle is only used if the polarizer is in the beam
+
+    @property
+    def gos_retarder_angle(self) -> float:
+        """Convert the retarder angle to a float if possible before returning."""
+        try:
+            return float(self.header[MetadataKey.gos_retarder_angle])
+        except ValueError:
+            return -999  # The angle is only used if the retarder is in the beam

{dkist_processing_common-11.7.0rc3 → dkist_processing_common-11.7.1rc1}/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-11.7.1rc1/dkist_processing_common/parsers/proposal_id_bud.py

@@ -0,0 +1,22 @@
+"""Proposal Id parser."""
+
+from dkist_processing_common.models.constants import BudName
+from dkist_processing_common.models.fits_access import MetadataKey
+from dkist_processing_common.parsers.id_bud import ContributingIdsBud
+from dkist_processing_common.parsers.id_bud import IdBud
+
+
+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)
+
+
+class ContributingProposalIdsBud(ContributingIdsBud):
+    """Class to create a Bud for the proposal_ids."""
+
+    def __init__(self):
+        super().__init__(
+            stem_name=BudName.contributing_proposal_ids, metadata_key=MetadataKey.proposal_id
+        )

{dkist_processing_common-11.7.0rc3 → dkist_processing_common-11.7.1rc1}/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