dkist-processing-cryonirsp 0.0.68__tar.gz → 0.0.70__tar.gz

{dkist_processing_cryonirsp-0.0.68 → dkist_processing_cryonirsp-0.0.70}/CHANGELOG.rst

@@ -1,3 +1,31 @@
+v0.0.70 (2024-06-25)
+====================
+
+Features
+--------
+
+- Use ParameterMixin paradigm from `dkist-processing-common` to simplify the definitions of Parameter classes. Specifically, this
+  means using the `ParameterWavelengthMixin` and `ParameterArmIdMixin` to provide support for parameters that depend on either wavelength
+  or arm ID. This functionality had existed previously, but now it is achieved by using standard tools in `dkist-processing-common`. (`#134 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/134>`__)
+
+
+Misc
+----
+
+- Move to version 8.0.0 of `dkist-processing-common`. This version changes the default behavior of `_find_most_recent_past_value` in
+  parameter classes. (`#134 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/134>`__)
+- Bump `dkist-processing-pac` to v3.0.2. No effect on `dkist-processing-cryonirsp`. (`#136 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/136>`__)
+
+
+v0.0.69 (2024-06-12)
+====================
+
+Misc
+----
+
+- Bump `dkist-fits-specifications` to v4.3.0. This version contains bugfixes for DL-NIRSP, but we want to say current. (`#133 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/133>`__)
+
+
 v0.0.68 (2024-06-12)
 ====================
 

{dkist_processing_cryonirsp-0.0.68 → dkist_processing_cryonirsp-0.0.70}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dkist_processing_cryonirsp
-Version: 0.0.68
+Version: 0.0.70
 Summary: Science processing code for the Cryo-NIRSP instrument on DKIST
 Home-page: https://bitbucket.org/dkistdc/dkist_processing_cryonirsp/src/main/
 Author: NSO / AURA

{dkist_processing_cryonirsp-0.0.68 → dkist_processing_cryonirsp-0.0.70}/dkist_processing_cryonirsp/models/parameters.py

@@ -1,29 +1,33 @@
 """CryoNIRSP calibration pipeline parameters."""
+from datetime import datetime
 from functools import cached_property
-from typing import Any
 
 import numpy as np
+from dkist_processing_common.models.parameters import ParameterArmIdMixin
 from dkist_processing_common.models.parameters import ParameterBase
-from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetParameterValue
+from dkist_processing_common.models.parameters import ParameterWavelengthMixin
 
 from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
 
 
-class CryonirspParameters(ParameterBase):
-    """Put all CryoNIRSP parameters parsed from the input dataset document in a single property."""
+class CryonirspParsingParameters(ParameterBase):
+    """
+    Parameters specifically (and only) for the Parse task.
+
+    Needed because the Parse task doesn't yet know about arm id, wavelength, or obs_ip_start_time, which are all
+    required to initialize the main parameter class.
+    """
 
-    def __init__(
-        self,
-        input_dataset_parameters: dict[str, list[InputDatasetParameterValue]],
-        wavelength: float | None = None,
-        arm_id: str | None = None,
-        obs_ip_start_time: str | None = None,
-    ):
-        super().__init__(
-            input_dataset_parameters=input_dataset_parameters, obs_ip_start_time=obs_ip_start_time
+    @property
+    def max_cs_step_time_sec(self):
+        """Time window within which CS steps with identical GOS configurations are considered to be the same."""
+        return self._find_most_recent_past_value(
+            "cryonirsp_max_cs_step_time_sec", start_date=datetime.now()
         )
-        self._wavelength = wavelength
-        self._arm_id = arm_id
+
+
+class CryonirspParameters(ParameterBase, ParameterWavelengthMixin, ParameterArmIdMixin):
+    """Put all CryoNIRSP parameters parsed from the input dataset document in a single property."""
 
     @property
     def geo_upsample_factor(self) -> int:
@@ -72,11 +76,6 @@ class CryonirspParameters(ParameterBase):
         """Return Number of demodulation matrices to compute across the entire FOV in the spatial dimension."""
         return self._find_most_recent_past_value("cryonirsp_polcal_num_spatial_bins")
 
-    @property
-    def max_cs_step_time_sec(self):
-        """Time window within which CS steps with identical GOS configurations are considered to be the same."""
-        return self._find_most_recent_past_value("cryonirsp_max_cs_step_time_sec")
-
     @property
     def polcal_pac_fit_mode(self):
         """Name of set of fitting flags to use during PAC Calibration Unit parameter fits."""
@@ -142,7 +141,7 @@ class CryonirspParameters(ParameterBase):
     def linearization_thresholds(self) -> np.ndarray:
         """Name of parameter associated with the linearization thresholds."""
         param_dict = self._find_parameter_for_arm("cryonirsp_linearization_thresholds")
-        value = self._load_param_value_from_npy_file(param_dict)
+        value = self._load_param_value_from_numpy_save(param_dict)
         # float64 data can blow up the memory required for linearization - convert to float32
         if np.issubdtype(value.dtype, np.float64):
             value = value.astype(np.float32, casting="same_kind")
@@ -234,34 +233,3 @@ class CryonirspParameters(ParameterBase):
     def _linearization_optical_density_filter_attenuation_open(self) -> float:
         """Return the attenuation value for a filter of 'Open'."""
         return 0.0
-
-    @staticmethod
-    def _load_param_value_from_npy_file(param_dict: dict) -> np.ndarray:
-        """Return the data associated with a parameter file saved in numpy format."""
-        file_path = param_dict["param_path"]
-        result = np.load(file_path)
-        return result
-
-    def _find_parameter_for_arm(self, parameter_name: str) -> Any:
-        full_param_name = f"{parameter_name}_{self._arm_id.lower()}"
-        param = self._find_most_recent_past_value(full_param_name)
-        return param
-
-    def _find_parameter_closest_wavelength(self, parameter_name: str) -> Any:
-        """
-        Find the database value for a parameter that is closest to the requested wavelength.
-
-        NOTE: If the requested wavelength is exactly between two database values, the value from the smaller wavelength
-        will be returned
-        """
-        if self._wavelength is None:
-            raise ValueError(
-                f"Cannot get wavelength dependent parameter {parameter_name} without wavelength"
-            )
-
-        parameter_dict = self._find_most_recent_past_value(parameter_name)
-        wavelengths = np.array(parameter_dict["wavelength"])
-        values = parameter_dict["values"]
-        idx = np.argmin(np.abs(wavelengths - self._wavelength))
-        chosen_value = values[idx]
-        return chosen_value

{dkist_processing_cryonirsp-0.0.68 → dkist_processing_cryonirsp-0.0.70}/dkist_processing_cryonirsp/tasks/parse.py

@@ -1,5 +1,4 @@
 """Parse CryoNIRSP data."""
-from abc import ABC
 from typing import TypeVar
 
 from dkist_processing_common.models.flower_pot import Stem
@@ -21,7 +20,7 @@ from dkist_processing_common.tasks import ParseDataBase
 from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetMixin
 
 from dkist_processing_cryonirsp.models.constants import CryonirspBudName
-from dkist_processing_cryonirsp.models.parameters import CryonirspParameters
+from dkist_processing_cryonirsp.models.parameters import CryonirspParsingParameters
 from dkist_processing_cryonirsp.models.tags import CryonirspStemName
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
@@ -51,35 +50,7 @@ __all__ = ["ParseL0CryonirspRampData", "ParseL0CryonirspLinearizedData"]
 S = TypeVar("S", bound=Stem)
 
 
-class ParseL0CryonirspDataBase(ParseDataBase, InputDatasetMixin, ABC):
-    """Base class for Cryonirsp Parsing classes.
-
-    Parameters
-    ----------
-    recipe_run_id : int
-        id of the recipe run used to identify the workflow run this task is part of
-    workflow_name : str
-        name of the workflow to which this instance of the task belongs
-    workflow_version : str
-        version of the workflow to which this instance of the task belongs
-
-    """
-
-    def __init__(
-        self,
-        recipe_run_id: int,
-        workflow_name: str,
-        workflow_version: str,
-    ):
-        super().__init__(
-            recipe_run_id=recipe_run_id,
-            workflow_name=workflow_name,
-            workflow_version=workflow_version,
-        )
-        self.parameters = CryonirspParameters(self.input_dataset_parameters)
-
-
-class ParseL0CryonirspRampData(ParseL0CryonirspDataBase):
+class ParseL0CryonirspRampData(ParseDataBase):
     """
     Parse CryoNIRSP ramp data (raw Cryo data) to prepare for Linearity Correction, after which the rest of the common parsing will occur.
 
@@ -153,9 +124,9 @@ class ParseL0CryonirspRampData(ParseL0CryonirspDataBase):
         return [Tag.input(), Tag.frame()]
 
 
-class ParseL0CryonirspLinearizedData(ParseL0CryonirspDataBase):
+class ParseL0CryonirspLinearizedData(ParseDataBase, InputDatasetMixin):
     """
-    Parse linearity corrected CryoNIRSP input data to add common and Cryonirsp specific parameters.
+    Parse linearity corrected CryoNIRSP input data to add common and Cryonirsp specific constants.
 
     Parameters
     ----------
@@ -168,6 +139,19 @@ class ParseL0CryonirspLinearizedData(ParseL0CryonirspDataBase):
 
     """
 
+    def __init__(
+        self,
+        recipe_run_id: int,
+        workflow_name: str,
+        workflow_version: str,
+    ):
+        super().__init__(
+            recipe_run_id=recipe_run_id,
+            workflow_name=workflow_name,
+            workflow_version=workflow_version,
+        )
+        self.parameters = CryonirspParsingParameters(self.input_dataset_parameters)
+
     @property
     def fits_parsing_class(self):
         """FITS access class to be used in this task."""

{dkist_processing_cryonirsp-0.0.68 → dkist_processing_cryonirsp-0.0.70}/dkist_processing_cryonirsp/tests/conftest.py

@@ -383,16 +383,22 @@ def assign_input_dataset_doc_to_task(
     testing_wavelength,
     testing_obs_ip_start_time,
 ):
-    def update_task(task, parameters):
+    def update_task(
+        task,
+        parameters,
+        parameter_class=CryonirspParameters,
+        arm_id: str = "SP",
+        obs_ip_start_time=testing_obs_ip_start_time,
+    ):
         doc_path = task.scratch.workflow_base_path / "dataset_doc.json"
         with open(doc_path, "w") as f:
             f.write(json.dumps(input_dataset_document_simple_parameters_part(parameters)))
         task.tag(doc_path, CryonirspTag.input_dataset_parameters())
-        task.parameters = CryonirspParameters(
+        task.parameters = parameter_class(
             task.input_dataset_parameters,
             wavelength=testing_wavelength,
-            arm_id=getattr(task.constants, "arm_id", None),
-            obs_ip_start_time=testing_obs_ip_start_time,
+            arm_id=arm_id,
+            obs_ip_start_time=obs_ip_start_time,
         )
 
     return update_task

{dkist_processing_cryonirsp-0.0.68 → dkist_processing_cryonirsp-0.0.70}/dkist_processing_cryonirsp/tests/test_parameters.py

@@ -11,15 +11,20 @@ from hypothesis import settings
 from hypothesis import strategies as st
 
 from dkist_processing_cryonirsp.models.parameters import CryonirspParameters
+from dkist_processing_cryonirsp.models.parameters import CryonirspParsingParameters
+from dkist_processing_cryonirsp.parsers.optical_density_filters import (
+    ALLOWABLE_OPTICAL_DENSITY_FILTERS,
+)
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
 from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
 from dkist_processing_cryonirsp.tests.conftest import CryonirspConstantsDb
 from dkist_processing_cryonirsp.tests.conftest import FileParameter
 from dkist_processing_cryonirsp.tests.conftest import TestingParameters
 
-# Definitions used throughout these tests:
-# test_params are the parameters defined in CryonirspTestingParameters()
-# task_params are the parameters defined in CryonirspParameters()
+# The property names of all parameters on `CryonirspParsingParameters`
+PARSE_PARAMETER_NAMES = [
+    k for k, v in vars(CryonirspParsingParameters).items() if isinstance(v, property)
+]
 
 
 @pytest.fixture(scope="function")
@@ -28,24 +33,41 @@ def basic_science_task_with_parameter_mixin(
     recipe_run_id,
     assign_input_dataset_doc_to_task,
     init_cryonirsp_constants_db,
+    testing_obs_ip_start_time,
 ):
-    class Task(CryonirspTaskBase):
-        def run(self):
-            ...
-
-    init_cryonirsp_constants_db(recipe_run_id, CryonirspConstantsDb())
-    task = Task(
-        recipe_run_id=recipe_run_id,
-        workflow_name="parse_cryonirsp_input_data",
-        workflow_version="VX.Y",
-    )
-    try:  # This try... block is here to make sure the dbs get cleaned up if there's a failure in the fixture
-        task.scratch = WorkflowFileSystem(scratch_base_path=tmp_path, recipe_run_id=recipe_run_id)
-        test_params = cryonirsp_testing_parameters_factory(param_path=tmp_path)
-        assign_input_dataset_doc_to_task(task, test_params())
-        yield task, test_params()
-    finally:
-        task._purge()
+    def make_task(
+        parameter_class=CryonirspParameters,
+        arm_id: str = "SP",
+        obs_ip_start_time: str = testing_obs_ip_start_time,
+    ):
+        class Task(CryonirspTaskBase):
+            def run(self):
+                ...
+
+        init_cryonirsp_constants_db(recipe_run_id, CryonirspConstantsDb())
+        task = Task(
+            recipe_run_id=recipe_run_id,
+            workflow_name="parse_cryonirsp_input_data",
+            workflow_version="VX.Y",
+        )
+        try:  # This try... block is here to make sure the dbs get cleaned up if there's a failure in the fixture
+            task.scratch = WorkflowFileSystem(
+                scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
+            )
+            test_params = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            param_dict = test_params()
+            assign_input_dataset_doc_to_task(
+                task,
+                param_dict,
+                parameter_class=parameter_class,
+                arm_id=arm_id,
+                obs_ip_start_time=obs_ip_start_time,
+            )
+            yield task, param_dict
+        finally:
+            task._purge()
+
+    return make_task
 
 
 def _is_wavelength_param(param_value: Any) -> bool:
@@ -61,7 +83,7 @@ def test_filter_parameters(basic_science_task_with_parameter_mixin, wave):
     When: Accessing properties for the optical density filters
     Then: The correct value is returned
     """
-    task, expected = basic_science_task_with_parameter_mixin
+    task, expected = next(basic_science_task_with_parameter_mixin())
     task_params = task.parameters
     task_params._wavelength = wave
     expected = {
@@ -85,7 +107,7 @@ def test_file_parameters(basic_science_task_with_parameter_mixin):
 
     This test exercises all aspects of file parameters from their names to the loading of values
     """
-    task, test_params = basic_science_task_with_parameter_mixin
+    task, test_params = next(basic_science_task_with_parameter_mixin())
     task_params = task.parameters
     # Iterate over the test parameters and check that each file param exists in the task parameters
     # we load the actual parameter from the task param object using only the param name
@@ -96,14 +118,14 @@ def test_file_parameters(basic_science_task_with_parameter_mixin):
             # If the param name is an attribute in task_params, then load it directly
             if hasattr(task_params, pn_no_prefix):
                 param_name = pn_no_prefix
-                actual = task_params._load_param_value_from_npy_file(
+                actual = task_params._load_param_value_from_numpy_save(
                     getattr(task_params, param_name)
                 )
             # if the param name is not a task param attribute, then check that we can load the param
             # using the value defined in the input_dataset_parameters list of the task param object
             else:
                 param_dict = task_params._find_most_recent_past_value(pn)
-                actual = task_params._load_param_value_from_npy_file(param_dict)
+                actual = task_params._load_param_value_from_numpy_save(param_dict)
             # Now get the expected value using the param value dict from the testing params
             expected = np.load(pv["param_path"])
             # Compare the actual and expected values
@@ -111,7 +133,10 @@ def test_file_parameters(basic_science_task_with_parameter_mixin):
 
 
 def _is_arm_param(
-    param_name: str, task_params: CryonirspParameters, testing_params: TestingParameters
+    param_name: str,
+    task_params: CryonirspParameters,
+    testing_params: TestingParameters,
+    single_arm_only: str | None = None,
 ):
     """
     Test if a parameter is an arm parameter.
@@ -122,7 +147,7 @@ def _is_arm_param(
     encapsulates the mechanism used to return the arm specific parameter value based on the arm in use.
     """
     # NB: param_name is assumed to have a prefix of "cryonirsp_"
-    arm_suffixes = ["_sp", "_ci"]
+    arm_suffixes = ["_sp", "_ci"] if single_arm_only is None else [f"_{single_arm_only}".casefold()]
     suffix = param_name[-3:]
     if suffix not in arm_suffixes:
         return False
@@ -135,7 +160,8 @@ def _is_arm_param(
     return hasattr(task_params, generic_param_name) and suffixed_names_exist
 
 
-def test_arm_parameters(basic_science_task_with_parameter_mixin):
+@pytest.mark.parametrize("arm_id", ["SP", "CI"])
+def test_arm_parameters(basic_science_task_with_parameter_mixin, arm_id):
     """
     Given: A Science task with the parameter mixin
     When: Accessing parameters that are "arm" parameters
@@ -146,21 +172,18 @@ def test_arm_parameters(basic_science_task_with_parameter_mixin):
     """
     # An arm parameter is one which is present in the param class with no arm suffix
     # and is also present in the testing param class with both suffix forms
-    task, test_params = basic_science_task_with_parameter_mixin
+    task, test_params = next(basic_science_task_with_parameter_mixin(arm_id=arm_id))
     task_params = task.parameters
     # Iterate over the test parameters
     for pn, pv in asdict(test_params).items():
-        # We want to test only generic parameters
-        if _is_arm_param(pn, task_params, test_params):
-            # get the generic param name
-            suffix = pn[-3:]
+        suffix = f"_{arm_id}".casefold()
+        if _is_arm_param(pn, task_params, test_params, single_arm_only=arm_id):
             generic_param_name = pn.removeprefix("cryonirsp_").removesuffix(suffix)
-            # Need to set arm_id here top make sure we get the right value
-            task_params._arm_id = suffix[-2:].upper()
+
             actual = getattr(task_params, generic_param_name)
             expected = getattr(test_params, pn)
             if isinstance(expected, FileParameter) and expected.is_file:
-                expected = task_params._load_param_value_from_npy_file(asdict(expected))
+                expected = task_params._load_param_value_from_numpy_save(asdict(expected))
                 assert np.array_equal(expected, actual)
             elif isinstance(actual, np.ndarray):
                 assert expected == actual.tolist()
@@ -168,22 +191,43 @@ def test_arm_parameters(basic_science_task_with_parameter_mixin):
                 assert expected == actual
 
 
-def test_other_parameters(basic_science_task_with_parameter_mixin):
+def test_parameters(basic_science_task_with_parameter_mixin):
     """
     Given: A Science task with the parameter mixin
     When: Accessing properties for parameters that are not wavelength, file or generic parameters
     Then: The correct value is returned
     """
-    task, test_params = basic_science_task_with_parameter_mixin
+    task, test_params = next(basic_science_task_with_parameter_mixin())
     task_params = task.parameters
     for pn, pv in asdict(test_params).items():
+        parameter_name = pn.removeprefix("cryonirsp_")
         if (
             _is_file_param(pv)
             or _is_wavelength_param(pv)
             or _is_arm_param(pn, task_params, test_params)
+            or parameter_name in PARSE_PARAMETER_NAMES
         ):
             continue
-        assert pv == getattr(task_params, pn.removeprefix("cryonirsp_"))
+        assert pv == getattr(task_params, parameter_name)
+
+
+def test_parse_parameters(basic_science_task_with_parameter_mixin):
+    """
+    Given: A Science task with ParsingParameters
+    When: Accessing properties for the parsing parameters
+    Then: The correct value is returned
+    """
+    task, test_params = next(
+        basic_science_task_with_parameter_mixin(
+            parameter_class=CryonirspParsingParameters,
+            obs_ip_start_time=None,
+        )
+    )
+    task_param_attr = task.parameters
+    for pn, pv in asdict(test_params).items():
+        property_name = pn.removeprefix("cryonirsp_")
+        if property_name in PARSE_PARAMETER_NAMES and type(pv) is not dict:
+            assert getattr(task_param_attr, property_name) == pv
 
 
 @pytest.mark.parametrize("arm", [pytest.param("CI"), pytest.param("SP")])
@@ -195,9 +239,25 @@ def test_linearization_threshold_parameters(
     When: Accessing properties for the linearization thresholds
     Then: The correct type is returned
     """
-    task, _ = basic_science_task_with_parameter_mixin
+    task, _ = next(basic_science_task_with_parameter_mixin())
     recipe_run_id = task.recipe_run_id
     init_cryonirsp_constants_db(recipe_run_id, CryonirspConstantsDb(ARM_ID=arm))
     linearization_threshold_array = task.parameters.linearization_thresholds
 
     assert linearization_threshold_array.dtype == np.float32
+
+
+def test_optical_density_filter_names(basic_science_task_with_parameter_mixin):
+    task, _ = next(basic_science_task_with_parameter_mixin())
+    # List of filter attenuation parameters defined in CryonirspParameters:
+    defined_filter_params = {
+        item[-4:].upper()
+        for item in dir(task.parameters)
+        if item.startswith("_linearization_optical_density_filter_attenuation_")
+    }
+    # List of filters in the filter map:
+    filter_map_params = {k for k in task.parameters.linearization_filter_attenuation_dict.keys()}
+    # Make sure all filter parameters match the allowable list
+    assert not defined_filter_params.symmetric_difference(ALLOWABLE_OPTICAL_DENSITY_FILTERS)
+    # Make sure all filter map keys match the allowable list
+    assert not filter_map_params.symmetric_difference(ALLOWABLE_OPTICAL_DENSITY_FILTERS)

{dkist_processing_cryonirsp-0.0.68 → dkist_processing_cryonirsp-0.0.70}/dkist_processing_cryonirsp/tests/test_parse.py

@@ -16,10 +16,8 @@ from dkist_processing_common.tests.conftest import FakeGQLClient
 from dkist_processing_cryonirsp.models.constants import CryonirspBudName
 from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
 from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
+from dkist_processing_cryonirsp.models.parameters import CryonirspParsingParameters
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
-from dkist_processing_cryonirsp.parsers.optical_density_filters import (
-    ALLOWABLE_OPTICAL_DENSITY_FILTERS,
-)
 from dkist_processing_cryonirsp.parsers.polarimetric_check import PolarimetricCheckingUniqueBud
 from dkist_processing_cryonirsp.tasks.parse import ParseL0CryonirspLinearizedData
 from dkist_processing_cryonirsp.tasks.parse import ParseL0CryonirspRampData
@@ -341,15 +339,20 @@ def parse_linearized_task(tmp_path, recipe_run_id, assign_input_dataset_doc_to_t
             task.scratch = WorkflowFileSystem(
                 scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
             )
-            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
-            assign_input_dataset_doc_to_task(task, param_class())
+            param_dataclass = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            assign_input_dataset_doc_to_task(
+                task,
+                param_dataclass(),
+                parameter_class=CryonirspParsingParameters,
+                obs_ip_start_time=None,
+            )
             yield task
         finally:
             task._purge()
 
 
 @pytest.fixture
-def parse_non_linearized_task(tmp_path, recipe_run_id, assign_input_dataset_doc_to_task, mocker):
+def parse_non_linearized_task(tmp_path, recipe_run_id, mocker):
     mocker.patch(
         "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
     )
@@ -362,8 +365,6 @@ def parse_non_linearized_task(tmp_path, recipe_run_id, assign_input_dataset_doc_
             task.scratch = WorkflowFileSystem(
                 scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
             )
-            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
-            assign_input_dataset_doc_to_task(task, param_class())
             yield task
         finally:
             task._purge()
@@ -1293,22 +1294,6 @@ def test_parse_cryonirsp_linearized_data_internal_scan_loops_as_map_scan_and_sca
     assert task.constants._db_dict[CryonirspBudName.num_map_scans.value] == num_alt_maps
 
 
-def test_optical_density_filter_names(parse_non_linearized_task):
-    task = parse_non_linearized_task
-    # List of filter attenuation parameters defined in CryonirspParameters:
-    defined_filter_params = {
-        item[-4:].upper()
-        for item in dir(task.parameters)
-        if item.startswith("_linearization_optical_density_filter_attenuation_")
-    }
-    # List of filters in the filter map:
-    filter_map_params = {k for k in task.parameters.linearization_filter_attenuation_dict.keys()}
-    # Make sure all filter parameters match the allowable list
-    assert not defined_filter_params.symmetric_difference(ALLOWABLE_OPTICAL_DENSITY_FILTERS)
-    # Make sure all filter map keys match the allowable list
-    assert not filter_map_params.symmetric_difference(ALLOWABLE_OPTICAL_DENSITY_FILTERS)
-
-
 @pytest.mark.parametrize("arm_id", ["CI", "SP"])
 def test_parse_cryonirsp_not_polarimetric_obs(parse_linearized_task, arm_id):
     """

{dkist_processing_cryonirsp-0.0.68 → dkist_processing_cryonirsp-0.0.70}/dkist_processing_cryonirsp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dkist-processing-cryonirsp
-Version: 0.0.68
+Version: 0.0.70
 Summary: Science processing code for the Cryo-NIRSP instrument on DKIST
 Home-page: https://bitbucket.org/dkistdc/dkist_processing_cryonirsp/src/main/
 Author: NSO / AURA

{dkist_processing_cryonirsp-0.0.68 → dkist_processing_cryonirsp-0.0.70}/dkist_processing_cryonirsp.egg-info/requires.txt

@@ -1,10 +1,10 @@
 Pillow==10.3.0
 astropy==6.1.0
-dkist-fits-specifications==4.2.0
+dkist-fits-specifications==4.3.0
 dkist-header-validator==5.1.0
-dkist-processing-common==7.0.0
+dkist-processing-common==8.0.0
 dkist-processing-math==2.1.0
-dkist-processing-pac==3.0.1
+dkist-processing-pac==3.0.2
 dkist-spectral-lines==3.0.0
 largestinteriorrectangle==0.2.0
 dkist-service-configuration==2.2

{dkist_processing_cryonirsp-0.0.68 → dkist_processing_cryonirsp-0.0.70}/setup.cfg

@@ -19,11 +19,11 @@ include_package_data = True
 install_requires = 
 	Pillow == 10.3.0
 	astropy == 6.1.0
-	dkist-fits-specifications == 4.2.0
+	dkist-fits-specifications == 4.3.0
 	dkist-header-validator == 5.1.0
-	dkist-processing-common == 7.0.0
+	dkist-processing-common == 8.0.0
 	dkist-processing-math == 2.1.0
-	dkist-processing-pac == 3.0.1
+	dkist-processing-pac == 3.0.2
 	dkist-spectral-lines == 3.0.0
 	largestinteriorrectangle == 0.2.0
 	dkist-service-configuration == 2.2

{dkist_processing_cryonirsp-0.0.68 → dkist_processing_cryonirsp-0.0.70}/dkist_processing_cryonirsp/tasks/cryonirsp_base.py

@@ -61,7 +61,7 @@ class CryonirspTaskBase(
         )
         self.parameters = CryonirspParameters(
             self.input_dataset_parameters,
+            obs_ip_start_time=self.constants.obs_ip_start_time,
             wavelength=self.constants.wavelength,
             arm_id=self.constants.arm_id,
-            obs_ip_start_time=self.constants.obs_ip_start_time,
         )