dkist-processing-common 12.6.2__tar.gz → 12.6.3__tar.gz

{dkist_processing_common-12.6.2 → dkist_processing_common-12.6.3}/CHANGELOG.rst

@@ -1,3 +1,22 @@
+v12.6.3 (2026-02-25)
+====================
+
+Bugfixes
+--------
+
+- Fix `CSStepFrameFlower` and `NumFramesPerCSStepBud` to correctly handle the multiple modstates present in each CS step. (`#306 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/306>`__)
+- Add correct HEADVERS, HEAD_URL, and CAL_URL keys to all dataset extras. (`#307 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/307>`__)
+
+
+Misc
+----
+
+- Add `modulator_state` as an expected property on `L0FitsAccess` to be clear about the expected interface in instrument-specific
+  subclasses. In the base `L0FitsAccess` class this property will raise a `NotImplementedError`. (`#306 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/306>`__)
+- Add `CSStepModstate` object, which adds modulation state awareness to the `CSStep` object used in parsing. (`#306 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/306>`__)
+- Move to `dkist-fits-specifications` v4.22.0, which includes HEADVERS in the schema for dataset extras. (`#307 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/307>`__)
+
+
 v12.6.2 (2026-02-19)
 ====================
 

{dkist_processing_common-12.6.2 → dkist_processing_common-12.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-common
-Version: 12.6.2
+Version: 12.6.3
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause
@@ -15,7 +15,7 @@ Requires-Python: >=3.13
 Description-Content-Type: text/x-rst
 Requires-Dist: asdf<4.0.0,>=3.5.0
 Requires-Dist: astropy>=7.0.0
-Requires-Dist: dkist-fits-specifications<5.0,>=4.21.0
+Requires-Dist: dkist-fits-specifications<5.0,>=4.22.0
 Requires-Dist: dkist-header-validator<6.0,>=5.3.0
 Requires-Dist: dkist-processing-core==7.0.2
 Requires-Dist: dkist-processing-pac<4.0,>=3.1

{dkist_processing_common-12.6.2 → dkist_processing_common-12.6.3}/dkist_processing_common/parsers/cs_step.py

@@ -7,6 +7,7 @@ from collections import Counter
 from collections import defaultdict
 from datetime import datetime
 from datetime import timezone
+from enum import StrEnum
 from typing import Type
 
 from dkist_processing_common.models.constants import BudName
@@ -27,8 +28,8 @@ class CSStep:
     This class allows for an easy way to quickly compare fits access objects to determine if they come from the
     same Calibration Sequence (CS) step. Each step in a CS is defined by the configuration of the GOS, namely the
     status of the polarizer and retarder (in or out) and the angle of each. Because some CS schemes call for some
-    GOS configurations to repeat a check is also made against the observation time for each object; the default in
-    the parameter store defines a maximum difference in time where two exposures are considered different CS steps
+    GOS configurations to repeat, a check is also made against the observation time for each object; the value of
+    ``max_cs_time_sec`` defines a maximum difference in time where two exposures are considered different CS steps
     regardless of GOS configuration.
 
     This class can also be sorted. In this case, only the observation time is taken into account.
@@ -60,9 +61,10 @@ class CSStep:
         self.max_cs_time_sec = max_cs_time_sec
 
         self.fits_obj_repr = repr(fits_obj)
+        self.angle_round_ndigits = angle_round_ndigits
 
     def __repr__(self):
-        return f"{self.__class__.__name__}({self.fits_obj_repr}, max_cs_time_sec={self.max_cs_time_sec!r})"
+        return f"{self.__class__.__name__}({self.fits_obj_repr}, max_cs_time_sec={self.max_cs_time_sec!r}, angle_round_ndigits={self.angle_round_ndigits})"
 
     def __str__(self):
         return "CS step with Pol = {}:{}, Ret = {}:{}, Dark = {}. Taken at {}".format(
@@ -76,8 +78,8 @@ class CSStep:
 
     def __eq__(self, other: object) -> bool:
         """Two steps are equal if they have the same GOS configuration and are taken within some package-defined time of each other."""
-        if not isinstance(other, CSStep):
-            raise TypeError(f"Cannot compare CSStep with type {type(other)}")
+        if not isinstance(other, type(self)):
+            raise TypeError(f"Cannot compare {type(self)} with {type(other)}")
 
         for item in ["pol_in", "pol_theta", "ret_in", "ret_theta", "dark_in"]:
             if getattr(self, item) != getattr(other, item):
@@ -98,6 +100,55 @@ class CSStep:
         return hash((self.pol_in, self.pol_theta, self.ret_in, self.ret_theta, self.dark_in))
 
 
+class CSStepModstate(CSStep):
+    """
+    Subclass of `CSStep` that is also aware of the modulation state associated with a given fits object.
+
+    This is used for grouping files based on CS step and modstate, which is useful when determining the number of frames
+    in a given CS step.
+
+    The equality and hash functionality of `CSStep` is extended to modulation state, and sorting remains only based on
+    observe time.
+    """
+
+    def __init__(
+        self,
+        fits_obj: L0FitsAccess,
+        max_cs_time_sec: float,
+        angle_round_ndigits: int = 1,
+    ):
+        super().__init__(
+            fits_obj=fits_obj,
+            max_cs_time_sec=max_cs_time_sec,
+            angle_round_ndigits=angle_round_ndigits,
+        )
+        self.modstate = fits_obj.modulator_state
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.fits_obj_repr}, max_cs_time_sec={self.max_cs_time_sec!r}, angle_round_ndigits={self.angle_round_ndigits})"
+
+    def __str__(self):
+        return (
+            "CS step with Pol = {}:{}, Ret = {}:{}, Dark = {}. Modstate = {}. Taken at {}".format(
+                self.pol_in,
+                self.pol_theta,
+                self.ret_in,
+                self.ret_theta,
+                self.dark_in,
+                self.modstate,
+                self.obs_time.isoformat(),
+            )
+        )
+
+    def __eq__(self, other: object) -> bool:
+        return super().__eq__(other) and self.modstate == other.modstate
+
+    def __hash__(self) -> int:
+        return hash(
+            (self.pol_in, self.pol_theta, self.ret_in, self.ret_theta, self.dark_in, self.modstate)
+        )
+
+
 class CSStepFlower(Stem):
     """
     Identify which CS Step a header belongs to.
@@ -167,7 +218,7 @@ class CSStepFrameFlower(Stem):
         self.max_cs_step_time_sec = max_cs_step_time_sec
         self.CS_step_dict = defaultdict(list)
 
-    def setter(self, fits_obj: L0FitsAccess) -> CSStep | Type[SpilledDirt]:
+    def setter(self, fits_obj: L0FitsAccess) -> CSStepModstate | Type[SpilledDirt]:
         """
         Set the CS Step for this fits object.
 
@@ -183,7 +234,10 @@ class CSStepFrameFlower(Stem):
         if fits_obj.ip_task_type != "polcal":
             return SpilledDirt
 
-        cs_step = CSStep(fits_obj, max_cs_time_sec=self.max_cs_step_time_sec)
+        cs_step = CSStepModstate(
+            fits_obj,
+            max_cs_time_sec=self.max_cs_step_time_sec,
+        )
         self.CS_step_dict[cs_step].append(cs_step)
         return cs_step
 
@@ -204,8 +258,8 @@ class CSStepFrameFlower(Stem):
         """
         cs_step_for_key = self.key_to_petal_dict[key]
 
-        # Use sorted's `key` here to guarantee we never hit `CSStep.__eq__`, which would consider all of these frames equal
-        # because they come from the same CS Step.
+        # Use sorted's `key` here to guarantee we never hit `CSStepModstate.__eq__`, which would consider all of these
+        # frames equal because they come from the same CS Step.
         frames_in_cs_step_list = sorted(
             self.CS_step_dict[cs_step_for_key], key=lambda cs: cs.obs_time
         )
@@ -275,7 +329,7 @@ class NumFramesPerCSStepBud(ListStem):
         super().__init__(stem_name=BudName.num_frames_per_cs_step)
         self.max_cs_step_time_sec = max_cs_step_time_sec
 
-    def setter(self, fits_obj: L0FitsAccess) -> CSStep | Type[SpilledDirt]:
+    def setter(self, fits_obj: L0FitsAccess) -> CSStepModstate | Type[SpilledDirt]:
         """
         Return the CS Step for this fits object.
 
@@ -290,13 +344,16 @@ class NumFramesPerCSStepBud(ListStem):
         """
         if fits_obj.ip_task_type != "polcal":
             return SpilledDirt
-        return CSStep(fits_obj, max_cs_time_sec=self.max_cs_step_time_sec)
+        return CSStepModstate(
+            fits_obj,
+            max_cs_time_sec=self.max_cs_step_time_sec,
+        )
 
     def getter(self) -> int:
         """
         Return number of frames per CS step.
 
-        We assume that each copy of the same `CSStep` object represents a single frame.
+        We assume that each copy of the same `CSStepModstate` object represents a single frame.
 
         Returns
         -------

{dkist_processing_common-12.6.2 → dkist_processing_common-12.6.3}/dkist_processing_common/parsers/l0_fits_access.py

@@ -6,6 +6,27 @@ from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.parsers.l1_fits_access import L1FitsAccess
 
 
+class AbstractProperty:
+    """
+    A class for defining properties expected to exist in subclasses, but that don't exist on the current class.
+
+    Use like this
+
+    .. code::
+
+      class BaseClass:
+        required_property = AbstractProperty()
+
+    Then accessing `BaseClass().required_property` will result in a `NotImplementedError`.
+    """
+
+    # Inspired by https://stackoverflow.com/questions/56997102/python-notimplementederror-for-instance-attributes
+    def __get__(self, *args, **kwargs):
+        raise NotImplementedError(
+            "This property needs to be defined manually in an instrument subclass"
+        )
+
+
 class L0FitsAccess(L1FitsAccess):
     """
     Class defining a fits access object for L0 input data.
@@ -20,6 +41,8 @@ class L0FitsAccess(L1FitsAccess):
         A boolean indicating whether to 'squeeze' out dimensions of size 1
     """
 
+    modulator_state: int = AbstractProperty()
+
     def __init__(
         self,
         hdu: fits.ImageHDU | fits.PrimaryHDU | fits.CompImageHDU,

{dkist_processing_common-12.6.2 → dkist_processing_common-12.6.3}/dkist_processing_common/tasks/write_extra.py

@@ -9,6 +9,7 @@ from typing import Literal
 import numpy as np
 from astropy.io import fits
 from astropy.time import Time
+from dkist_fits_specifications import __version__ as spec_version
 from dkist_fits_specifications.utils.formatter import reformat_dataset_extra_header
 from dkist_header_validator.spec_validators import spec_extras_validator
 
@@ -150,6 +151,8 @@ class WriteL1DatasetExtras(WriteL1Base, ABC):
         start_datetime = datetime.fromisoformat(task_specific_date_begin)
         end_datetime = datetime.fromisoformat(header_data.end_time)
 
+        inst_name = self.constants.instrument.lower()
+        calvers = self.version_from_module_name()
         dataset_extra_header = {
             DatasetExtraHeaderSection.common: {
                 "BUNIT": "count",
@@ -181,10 +184,11 @@ class WriteL1DatasetExtras(WriteL1Base, ABC):
                 "RECIPEID": self.metadata_store_recipe_run.recipeInstance.recipeId,
                 "RINSTID": self.metadata_store_recipe_run.recipeInstanceId,
                 "FILENAME": header_data.filename,
-                "HEAD_URL": "",
+                "HEADVERS": spec_version,
+                "HEAD_URL": f"{self.docs_base_url}/projects/data-products/en/v{spec_version}",
                 "INFO_URL": self.docs_base_url,
-                "CAL_URL": "",
-                "CALVERS": self.version_from_module_name(),
+                "CAL_URL": f"{self.docs_base_url}/projects/{inst_name}/en/v{calvers}/{self.workflow_name}.html",
+                "CALVERS": calvers,
                 "IDSPARID": (
                     parameters.inputDatasetPartId
                     if (parameters := self.metadata_store_input_dataset_parameters)

{dkist_processing_common-12.6.2 → dkist_processing_common-12.6.3}/dkist_processing_common/tests/conftest.py

@@ -7,6 +7,7 @@ from collections import defaultdict
 from copy import deepcopy
 from datetime import datetime
 from datetime import timedelta
+from enum import StrEnum
 from pathlib import Path
 from random import choice
 from random import randint
@@ -196,7 +197,9 @@ class CalibrationSequenceDataset(Spec122Dataset):
         instrument="visp",
         angle_max_random_perturbation: float = 0.049,
         num_frames_per_CS_step: int = 5,
+        num_modstates: int = 8,
     ):
+        self.num_modstates = num_modstates
         self.num_frames_per_CS_step = num_frames_per_CS_step
         self.angle_max_random_perturbation = angle_max_random_perturbation
         # Make up a Calibration sequence. Mostly random except for two clears and two darks at start and end, which
@@ -224,7 +227,10 @@ class CalibrationSequenceDataset(Spec122Dataset):
         ]
 
         self.num_steps = len(self.pol_theta)
-        dataset_shape = (self.num_steps * self.num_frames_per_CS_step,) + array_shape[1:]
+        dataset_shape = (
+            self.num_steps * self.num_modstates,
+            self.num_frames_per_CS_step,
+        ) + array_shape[1:]
         super().__init__(
             dataset_shape,
             array_shape,
@@ -240,7 +246,11 @@ class CalibrationSequenceDataset(Spec122Dataset):
 
     @property
     def cs_step(self) -> int:
-        return self.index // self.num_frames_per_CS_step
+        return self.index // (self.num_modstates * self.num_frames_per_CS_step)
+
+    @key_function("VISP_011")
+    def modstate(self, key: str) -> int:
+        return ((self.index // self.num_frames_per_CS_step) % self.num_modstates) + 1
 
     @key_function("PAC__004")
     def polarizer_status(self, key: str) -> str:
@@ -284,6 +294,17 @@ class NonPolCalDataset(Spec122Dataset):
         self.add_constant_key("PAC__008", "DarkShutter")
 
 
+class ModstateFitsAccess(L0FitsAccess):
+    def __init__(
+        self,
+        hdu: fits.ImageHDU | fits.PrimaryHDU | fits.CompImageHDU,
+        name: str | None = None,
+        auto_squeeze: bool = True,
+    ):
+        super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
+        self.modulator_state: int = self.header["VSPSTNUM"]
+
+
 @pytest.fixture(scope="session")
 def cs_step_angle_round_ndigits() -> int:
     return 1
@@ -296,6 +317,11 @@ def angle_random_max_perturbation(cs_step_angle_round_ndigits) -> float:
     return 10**-cs_step_angle_round_ndigits / 2 - 10 ** -(cs_step_angle_round_ndigits + 2)
 
 
+@pytest.fixture(scope="session")
+def num_modstates() -> int:
+    return 4
+
+
 @pytest.fixture(scope="session")
 def num_frames_per_cs_step() -> int:
     return 3
@@ -303,13 +329,14 @@ def num_frames_per_cs_step() -> int:
 
 @pytest.fixture(scope="session")
 def grouped_cal_sequence_fits_objs(
-    angle_random_max_perturbation, num_frames_per_cs_step
-) -> dict[int, list[L0FitsAccess]]:
+    angle_random_max_perturbation, num_modstates, num_frames_per_cs_step
+) -> dict[int, list[ModstateFitsAccess]]:
     ds = CalibrationSequenceDataset(
         array_shape=(1, 2, 2),
         time_delta=2.0,
         angle_max_random_perturbation=angle_random_max_perturbation,
         num_frames_per_CS_step=num_frames_per_cs_step,
+        num_modstates=num_modstates,
     )
     header_list = [
         spec122_validator.validate_and_translate_to_214_l0(d.header(), return_type=fits.HDUList)[
@@ -319,9 +346,40 @@ def grouped_cal_sequence_fits_objs(
     ]
     expected_cs_dict = defaultdict(list)
     for i in range(ds.num_steps):
-        for j in range(ds.num_frames_per_CS_step):
-            expected_cs_dict[i].append(L0FitsAccess.from_header(header_list.pop(0)))
+        for m in range(ds.num_modstates):
+            for j in range(ds.num_frames_per_CS_step):
+                expected_cs_dict[i].append(ModstateFitsAccess.from_header(header_list.pop(0)))
+
+    # Make sure we used all the dataset frames
+    assert len(header_list) == 0
+    return expected_cs_dict
+
+
+@pytest.fixture(scope="session")
+def grouped_cal_sequence_modstate_fits_objs(
+    angle_random_max_perturbation, num_modstates, num_frames_per_cs_step
+) -> dict[int, dict[int, list[ModstateFitsAccess]]]:
+    ds = CalibrationSequenceDataset(
+        array_shape=(1, 2, 2),
+        time_delta=2.0,
+        angle_max_random_perturbation=angle_random_max_perturbation,
+        num_frames_per_CS_step=num_frames_per_cs_step,
+        num_modstates=num_modstates,
+    )
+    header_list = [
+        spec122_validator.validate_and_translate_to_214_l0(d.header(), return_type=fits.HDUList)[
+            0
+        ].header
+        for d in ds
+    ]
+    expected_cs_dict = defaultdict(lambda: defaultdict(list))
+    for i in range(ds.num_steps):
+        for m in range(ds.num_modstates):
+            for j in range(ds.num_frames_per_CS_step):
+                expected_cs_dict[i][m].append(ModstateFitsAccess.from_header(header_list.pop(0)))
 
+    # Make sure we used all the dataset frames
+    assert len(header_list) == 0
     return expected_cs_dict
 
 
@@ -341,7 +399,7 @@ def non_polcal_fits_objs() -> list[L0FitsAccess]:
 @pytest.fixture(scope="session")
 def max_cs_step_time_sec() -> float:
     """Max CS step time in seconds"""
-    return 15.0
+    return 30.0
 
 
 ####################################

{dkist_processing_common-12.6.2 → dkist_processing_common-12.6.3}/dkist_processing_common/tests/test_construct_dataset_extras.py

@@ -6,6 +6,7 @@ from pathlib import Path
 import numpy as np
 import pytest
 from astropy.io import fits
+from dkist_fits_specifications import __version__ as spec_version
 
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_array_decoder
@@ -385,6 +386,18 @@ def test_construct_dataset_extras(
                 "DEMODULATION MATRICES",
                 "POLCAL AS SCIENCE",
             ]
+            assert header["INFO_URL"] == task.docs_base_url
+            assert header["HEADVERS"] == spec_version
+            assert (
+                header["HEAD_URL"]
+                == f"{task.docs_base_url}/projects/data-products/en/v{spec_version}"
+            )
+            calvers = task.version_from_module_name()
+            assert header["CALVERS"] == calvers
+            assert (
+                header["CAL_URL"]
+                == f"{task.docs_base_url}/projects/{task.constants.instrument.lower()}/en/v{calvers}/{task.workflow_name}.html"
+            )
             if header["IPTASK"] == "POLCAL":
                 assert "POLANGLE" not in header
             else:

dkist_processing_common-12.6.3/dkist_processing_common/tests/test_cs_step.py

@@ -0,0 +1,111 @@
+import random
+
+import numpy as np
+import pytest
+
+from dkist_processing_common.parsers.cs_step import CSStep
+from dkist_processing_common.parsers.cs_step import CSStepModstate
+
+
+def test_equality_correct(
+    grouped_cal_sequence_fits_objs, max_cs_step_time_sec, cs_step_angle_round_ndigits
+):
+    """
+    Given: A set of PolCal headers
+    When: Converting them to CSStep objects and comparing them
+    Then: All headers belonging to the same step produce CSStep objects that are equal and are not equal to CSStep objects
+          from other steps
+    """
+    num_steps = len(grouped_cal_sequence_fits_objs)
+    for step in range(num_steps):
+        for i in range(num_steps):
+            objs_equal = CSStep(
+                grouped_cal_sequence_fits_objs[step][0], max_cs_step_time_sec
+            ) == CSStep(grouped_cal_sequence_fits_objs[i][0], max_cs_step_time_sec)
+            assert objs_equal == (step == i)
+
+
+def test_csstepmodstate_equality_correct(
+    grouped_cal_sequence_modstate_fits_objs,
+    num_modstates,
+    max_cs_step_time_sec,
+    cs_step_angle_round_ndigits,
+):
+    """
+    Given: A set of PolCal headers
+    When: Converting them to CSStepModstate objects and comparing them
+    Then: All headers belonging to the same step and modstate produce CSStepModstate objects that are equal and that are
+          not equal to CSStepModstate objects from other steps and modstates
+    """
+    num_steps = len(grouped_cal_sequence_modstate_fits_objs)
+    for step, modstate_dict in grouped_cal_sequence_modstate_fits_objs.items():
+        for modstate in range(num_modstates):
+            for ss in range(num_steps):
+                for mm in range(num_modstates):
+                    objs_equal = CSStepModstate(
+                        grouped_cal_sequence_modstate_fits_objs[step][modstate][0],
+                        max_cs_step_time_sec,
+                    ) == CSStepModstate(
+                        grouped_cal_sequence_modstate_fits_objs[ss][mm][0],
+                        max_cs_step_time_sec,
+                    )
+                    assert objs_equal == (ss == step and mm == modstate)
+
+
+@pytest.mark.parametrize(
+    "step_class",
+    [pytest.param(CSStep, id="CSStep"), pytest.param(CSStepModstate, id="CSStepModstate")],
+)
+def test_not_equal_non_CS_Step_type(
+    grouped_cal_sequence_fits_objs, step_class, max_cs_step_time_sec
+):
+    """
+    Given: A PolCal header and resulting CSStep[Modstate] object
+    When: Testing equality with a non CSStep object
+    Then: An error is raised
+    """
+    cs_step = step_class(grouped_cal_sequence_fits_objs[0][0], max_cs_step_time_sec)
+    with pytest.raises(
+        TypeError,
+        match=f"Cannot compare <class 'dkist_processing_common.parsers.cs_step.{step_class.__name__}'> with <class 'int'>",
+    ):
+        _ = cs_step == 1
+
+
+@pytest.mark.parametrize(
+    "step_class",
+    [pytest.param(CSStep, id="CSStep"), pytest.param(CSStepModstate, id="CSStepModstate")],
+)
+def test_order_correct(grouped_cal_sequence_fits_objs, step_class, max_cs_step_time_sec):
+    """
+    Given: A set of PolCal headers
+    When: Converting them to CSStep[Modstate] objects and ordering them
+    Then: The step objects are correctly ordered by observe time
+    """
+    cs_step_list = [
+        step_class(header, max_cs_step_time_sec)
+        for header in sum(grouped_cal_sequence_fits_objs.values(), [])
+    ]
+    random.shuffle(cs_step_list)  # Just to mix it up a bit
+    time_list = [c.obs_time for c in cs_step_list]
+    cs_sort_idx = np.argsort(cs_step_list)
+    time_sort_idx = np.argsort(time_list)
+    assert np.array_equal(cs_sort_idx, time_sort_idx)
+
+
+@pytest.mark.parametrize(
+    "step_class",
+    [pytest.param(CSStep, id="CSStep"), pytest.param(CSStepModstate, id="CSStepModstate")],
+)
+def test_repr(grouped_cal_sequence_fits_objs, step_class):
+    """
+    Given: An `L0FitsAccess` object
+    When: Using that object to instantiate `CSStep[Modstate]`
+    Then: The repr of the instance is correct
+    """
+    fits_obj = grouped_cal_sequence_fits_objs[0][0]
+    cs_step_obj = step_class(fits_obj, max_cs_time_sec=10, angle_round_ndigits=5)
+    assert (
+        repr(cs_step_obj)
+        == f"{step_class.__name__}({fits_obj!r}, max_cs_time_sec=10, angle_round_ndigits=5)"
+    )

{dkist_processing_common-12.6.2 → dkist_processing_common-12.6.3}/dkist_processing_common/tests/test_fits_access.py

@@ -145,6 +145,17 @@ class FitsAccessWithNaxisKeys(FitsAccessBase):
         self.naxis2 = self.header[MetadataKeyWithNaxisKeys.naxis2]
 
 
+class FitsAccessWithModstate(L0FitsAccess):
+    def __init__(
+        self,
+        hdu: fits.ImageHDU | fits.PrimaryHDU | fits.CompImageHDU,
+        name: str | None = None,
+        auto_squeeze: bool = True,
+    ):
+        super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
+        self.modulator_state = 5
+
+
 def test_metadata_keys_in_access_bases(hdu_with_no_data):
     """
     Given: a set of metadata key names in the MetadataKey sting enumeration
@@ -348,3 +359,20 @@ def test_from_header_naxis_preserved(header_type):
     assert fits_obj.naxis == 2
     assert fits_obj.naxis1 == 123
     assert fits_obj.naxis2 == 456
+
+
+def test_l0fitsaccess_modulator_state(hdu_with_no_data):
+    """
+    Given: Instances of both the base `L0FitsAccess` class and a subclass of the same that defines the `modulator_state` property
+    When: Accessing the `modulator_state` property on both classes
+    Then: The base `L0FitsAccess` instance raises the appropriate error and the subclass returns the correct value
+    """
+    l0_obj = L0FitsAccess(hdu=hdu_with_no_data)
+    with pytest.raises(
+        NotImplementedError,
+        match="This property needs to be defined manually in an instrument subclass",
+    ):
+        _ = l0_obj.modulator_state
+
+    child_obj = FitsAccessWithModstate(hdu=hdu_with_no_data)
+    assert child_obj.modulator_state == 5

{dkist_processing_common-12.6.2 → dkist_processing_common-12.6.3}/dkist_processing_common/tests/test_stems.py

@@ -501,14 +501,15 @@ def test_cs_step_flower(grouped_cal_sequence_fits_objs, non_polcal_fits_objs, ma
 
     assert len(list(cs_step_flower.petals)) == len(list(grouped_cal_sequence_fits_objs.keys()))
     for step_petal in cs_step_flower.petals:
-        assert sorted(step_petal.keys) == [
-            f"step_{step_petal.value}_file_{i}" for i in range(len(step_petal.keys))
-        ]
+        assert sorted(step_petal.keys) == sorted(
+            [f"step_{step_petal.value}_file_{i}" for i in range(len(step_petal.keys))]
+        )
 
 
 def test_cs_step_frame_flower(
-    grouped_cal_sequence_fits_objs,
+    grouped_cal_sequence_modstate_fits_objs,
     non_polcal_fits_objs,
+    num_modstates,
     num_frames_per_cs_step,
     max_cs_step_time_sec,
 ):
@@ -517,24 +518,31 @@ def test_cs_step_frame_flower(
     When: Updating the CSStepFrameFlower with all headers
     Then: The flower correctly organizes the PolCal frames and ignores the non-PolCal frames
     """
-    cs_step_frame_flower = CSStepFrameFlower(max_cs_step_time_sec=max_cs_step_time_sec)
+    cs_step_frame_flower = CSStepFrameFlower(
+        max_cs_step_time_sec=max_cs_step_time_sec,
+    )
     assert cs_step_frame_flower.stem_name == StemName.cs_step_frame
 
-    num_cs_steps = len(grouped_cal_sequence_fits_objs)
-    for step, objs in grouped_cal_sequence_fits_objs.items():
-        file_names = [f"step_{step}_file_{i}" for i in range(len(objs))]
-        # Reverse the lists here just to make sure we're not relying on pre-sorted inputs
-        for o, k in zip(objs[::-1], file_names[::-1]):
-            cs_step_frame_flower.update(k, o)
+    num_cs_steps = len(grouped_cal_sequence_modstate_fits_objs)
+    for step, modstate_dict in grouped_cal_sequence_modstate_fits_objs.items():
+        for m, objs in modstate_dict.items():
+            file_names = [f"step_{step}_mod_{m}_file_{i}" for i in range(len(objs))]
+            # Reverse the lists here just to make sure we're not relying on pre-sorted inputs
+            for o, k in zip(objs[::-1], file_names[::-1]):
+                cs_step_frame_flower.update(k, o)
 
     for o in non_polcal_fits_objs:
         cs_step_frame_flower.update("non_polcal", o)
 
     assert len(list(cs_step_frame_flower.petals)) == num_frames_per_cs_step
     for frame_petal in cs_step_frame_flower.petals:
-        assert sorted(frame_petal.keys) == [
-            f"step_{step}_file_{frame_petal.value}" for step in range(num_cs_steps)
-        ]
+        assert sorted(frame_petal.keys) == sorted(
+            [
+                f"step_{step}_mod_{m}_file_{frame_petal.value}"
+                for step in range(num_cs_steps)
+                for m in range(num_modstates)
+            ]
+        )
 
 
 def test_num_cs_step_bud(
@@ -569,7 +577,9 @@ def test_num_frames_per_cs_step_bud(
     When: Updating the bud with the headers
     Then: The bud correctly parses the number of frames per CS step
     """
-    num_frames_per_cs_bud_obj = NumFramesPerCSStepBud(max_cs_step_time_sec=max_cs_step_time_sec)
+    num_frames_per_cs_bud_obj = NumFramesPerCSStepBud(
+        max_cs_step_time_sec=max_cs_step_time_sec,
+    )
     num_cs_steps = len(grouped_cal_sequence_fits_objs)
     for i, (step, objs) in enumerate(grouped_cal_sequence_fits_objs.items()):
         if skip_frame and i == num_cs_steps - 1:

{dkist_processing_common-12.6.2 → dkist_processing_common-12.6.3}/dkist_processing_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-common
-Version: 12.6.2
+Version: 12.6.3
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause
@@ -15,7 +15,7 @@ Requires-Python: >=3.13
 Description-Content-Type: text/x-rst
 Requires-Dist: asdf<4.0.0,>=3.5.0
 Requires-Dist: astropy>=7.0.0
-Requires-Dist: dkist-fits-specifications<5.0,>=4.21.0
+Requires-Dist: dkist-fits-specifications<5.0,>=4.22.0
 Requires-Dist: dkist-header-validator<6.0,>=5.3.0
 Requires-Dist: dkist-processing-core==7.0.2
 Requires-Dist: dkist-processing-pac<4.0,>=3.1