dkist-processing-cryonirsp 1.4.20__py3-none-any.whl → 1.14.9rc1__py3-none-any.whl

dkist_processing_cryonirsp/tasks/parse.py

@@ -1,27 +1,30 @@
 """Parse CryoNIRSP data."""
+
 from typing import TypeVar
 
+from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.models.flower_pot import Stem
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.cs_step import CSStepFlower
 from dkist_processing_common.parsers.cs_step import NumCSStepBud
 from dkist_processing_common.parsers.near_bud import TaskNearFloatBud
+from dkist_processing_common.parsers.retarder import RetarderNameBud
 from dkist_processing_common.parsers.single_value_single_key_flower import (
     SingleValueSingleKeyFlower,
 )
-from dkist_processing_common.parsers.task import parse_header_ip_task_with_gains
 from dkist_processing_common.parsers.task import PolcalTaskFlower
 from dkist_processing_common.parsers.task import TaskTypeFlower
+from dkist_processing_common.parsers.task import parse_header_ip_task_with_gains
 from dkist_processing_common.parsers.time import ObsIpStartTimeBud
 from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
 from dkist_processing_common.parsers.unique_bud import UniqueBud
+from dkist_processing_common.tasks import ParseDataBase
 from dkist_processing_common.tasks import default_constant_bud_factory
 from dkist_processing_common.tasks import default_tag_flower_factory
-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.fits_access import CryonirspMetadataKey
 from dkist_processing_cryonirsp.models.parameters import CryonirspParsingParameters
 from dkist_processing_cryonirsp.models.tags import CryonirspStemName
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
@@ -53,11 +56,10 @@ from dkist_processing_cryonirsp.parsers.optical_density_filters import OpticalDe
 from dkist_processing_cryonirsp.parsers.polarimetric_check import PolarimetricCheckingUniqueBud
 from dkist_processing_cryonirsp.parsers.scan_step import NumberOfScanStepsBud
 from dkist_processing_cryonirsp.parsers.scan_step import ScanStepNumberFlower
-from dkist_processing_cryonirsp.parsers.time import CryonirspSolarGainStartTimeBud
+from dkist_processing_cryonirsp.parsers.time import CryonirspSolarGainTimeObsBud
 from dkist_processing_cryonirsp.parsers.time import CryonirspTimeObsBud
 from dkist_processing_cryonirsp.parsers.wavelength import ObserveWavelengthBud
 
-
 __all__ = [
     "ParseL0CryonirspRampData",
     "ParseL0CryonirspLinearizedData",
@@ -92,13 +94,15 @@ class ParseL0CryonirspRampData(ParseDataBase):
         """Add CryoNIRSP specific constants to common constants."""
         return [
             UniqueBud(
-                constant_name=CryonirspBudName.camera_readout_mode.value,
-                metadata_key="camera_readout_mode",
+                constant_name=CryonirspBudName.camera_readout_mode,
+                metadata_key=CryonirspMetadataKey.camera_readout_mode,
             ),
             # Time Obs is the unique identifier for each ramp in the data set
             CryonirspTimeObsBud(),
             # This is used to determine which set of linearity correction tables to use.
-            UniqueBud(constant_name=CryonirspBudName.arm_id.value, metadata_key="arm_id"),
+            UniqueBud(
+                constant_name=CryonirspBudName.arm_id, metadata_key=CryonirspMetadataKey.arm_id
+            ),
             # Need wavelength to do filter compensation
             ObserveWavelengthBud(),
             # Need the optical density filter name for early failure detection
@@ -107,16 +111,20 @@ class ParseL0CryonirspRampData(ParseDataBase):
             ObsIpStartTimeBud(),
             # Get the ROI 1 size and origin
             UniqueBud(
-                constant_name=CryonirspBudName.roi_1_origin_x.value, metadata_key="roi_1_origin_x"
+                constant_name=CryonirspBudName.roi_1_origin_x,
+                metadata_key=CryonirspMetadataKey.roi_1_origin_x,
             ),
             UniqueBud(
-                constant_name=CryonirspBudName.roi_1_origin_y.value, metadata_key="roi_1_origin_y"
+                constant_name=CryonirspBudName.roi_1_origin_y,
+                metadata_key=CryonirspMetadataKey.roi_1_origin_y,
             ),
             UniqueBud(
-                constant_name=CryonirspBudName.roi_1_size_x.value, metadata_key="roi_1_size_x"
+                constant_name=CryonirspBudName.roi_1_size_x,
+                metadata_key=CryonirspMetadataKey.roi_1_size_x,
             ),
             UniqueBud(
-                constant_name=CryonirspBudName.roi_1_size_y.value, metadata_key="roi_1_size_y"
+                constant_name=CryonirspBudName.roi_1_size_y,
+                metadata_key=CryonirspMetadataKey.roi_1_size_y,
             ),
         ]
 
@@ -125,13 +133,13 @@ class ParseL0CryonirspRampData(ParseDataBase):
         """Add CryoNIRSP specific tags to common tags."""
         return [
             SingleValueSingleKeyFlower(
-                tag_stem_name=CryonirspStemName.curr_frame_in_ramp.value,
-                metadata_key="curr_frame_in_ramp",
+                tag_stem_name=CryonirspStemName.curr_frame_in_ramp,
+                metadata_key=CryonirspMetadataKey.curr_frame_in_ramp,
             ),
             # time_obs is a unique identifier for all raw frames in a single ramp
             SingleValueSingleKeyFlower(
-                tag_stem_name=CryonirspStemName.time_obs.value,
-                metadata_key="time_obs",
+                tag_stem_name=CryonirspStemName.time_obs,
+                metadata_key=MetadataKey.time_obs,
             ),
         ]
 
@@ -141,7 +149,7 @@ class ParseL0CryonirspRampData(ParseDataBase):
         return [Tag.input(), Tag.frame()]
 
 
-class ParseL0CryonirspLinearizedData(ParseDataBase, InputDatasetMixin):
+class ParseL0CryonirspLinearizedData(ParseDataBase):
     """
     Parse linearity corrected CryoNIRSP input data to add common and Cryonirsp specific constants.
 
@@ -167,7 +175,7 @@ class ParseL0CryonirspLinearizedData(ParseDataBase, InputDatasetMixin):
             workflow_name=workflow_name,
             workflow_version=workflow_version,
         )
-        self.parameters = CryonirspParsingParameters(self.input_dataset_parameters)
+        self.parameters = CryonirspParsingParameters(scratch=self.scratch)
 
     @property
     def fits_parsing_class(self):
@@ -186,36 +194,46 @@ class ParseL0CryonirspLinearizedData(ParseDataBase, InputDatasetMixin):
             NumMapScansBud(),
             NumberOfScanStepsBud(),
             NumberOfMeasurementsBud(),
-            CryonirspSolarGainStartTimeBud(),
+            CryonirspSolarGainTimeObsBud(),
             CheckSolarGainFramesPickyBud(),
             NumCSStepBud(self.parameters.max_cs_step_time_sec),
             CryonirspTaskExposureConditionsBud(
-                stem_name=CryonirspBudName.dark_frame_exposure_conditions_list.value,
-                ip_task_type=TaskName.dark.value,
+                stem_name=CryonirspBudName.dark_frame_exposure_conditions_list,
+                ip_task_type=TaskName.dark,
             ),
             CryonirspTaskExposureConditionsBud(
-                stem_name=CryonirspBudName.solar_gain_exposure_conditions_list.value,
-                ip_task_type=TaskName.solar_gain.value,
+                stem_name=CryonirspBudName.solar_gain_exposure_conditions_list,
+                ip_task_type=TaskName.solar_gain,
             ),
             CryonirspTaskExposureConditionsBud(
-                stem_name=CryonirspBudName.observe_exposure_conditions_list.value,
-                ip_task_type=TaskName.observe.value,
+                stem_name=CryonirspBudName.observe_exposure_conditions_list,
+                ip_task_type=TaskName.observe,
             ),
             CryonirspTaskExposureConditionsBud(
-                stem_name=CryonirspBudName.polcal_exposure_conditions_list.value,
-                ip_task_type=TaskName.polcal.value,
+                stem_name=CryonirspBudName.polcal_exposure_conditions_list,
+                ip_task_type=TaskName.polcal,
+            ),
+            UniqueBud(
+                constant_name=CryonirspBudName.axis_1_type,
+                metadata_key=CryonirspMetadataKey.axis_1_type,
+            ),
+            UniqueBud(
+                constant_name=CryonirspBudName.axis_2_type,
+                metadata_key=CryonirspMetadataKey.axis_2_type,
+            ),
+            UniqueBud(
+                constant_name=CryonirspBudName.axis_3_type,
+                metadata_key=CryonirspMetadataKey.axis_3_type,
             ),
-            UniqueBud(constant_name=CryonirspBudName.axis_1_type.value, metadata_key="axis_1_type"),
-            UniqueBud(constant_name=CryonirspBudName.axis_2_type.value, metadata_key="axis_2_type"),
-            UniqueBud(constant_name=CryonirspBudName.axis_3_type.value, metadata_key="axis_3_type"),
             PolarimetricCheckingUniqueBud(
-                constant_name=CryonirspBudName.num_modstates.value,
-                metadata_key="number_of_modulator_states",
+                constant_name=CryonirspBudName.num_modstates,
+                metadata_key=CryonirspMetadataKey.number_of_modulator_states,
             ),
             PolarimetricCheckingUniqueBud(
-                constant_name=CryonirspBudName.modulator_spin_mode.value,
-                metadata_key="modulator_spin_mode",
+                constant_name=CryonirspBudName.modulator_spin_mode,
+                metadata_key=CryonirspMetadataKey.modulator_spin_mode,
             ),
+            RetarderNameBud(),
         ]
 
     @property
@@ -230,7 +248,7 @@ class ParseL0CryonirspLinearizedData(ParseDataBase, InputDatasetMixin):
             ScanStepNumberFlower(),
             MeasurementNumberFlower(),
             SingleValueSingleKeyFlower(
-                tag_stem_name=CryonirspStemName.exposure_conditions.value,
+                tag_stem_name=CryonirspStemName.exposure_conditions,
                 metadata_key="exposure_conditions",
             ),
         ]
@@ -244,41 +262,41 @@ class ParseL0CryonirspSPLinearizedData(ParseL0CryonirspLinearizedData):
         """Add CryoNIRSP-SP specific constants to common constants."""
         return super().constant_buds + [
             TaskNearFloatBud(
-                constant_name=CryonirspBudName.grating_position_deg.value,
-                metadata_key="grating_position_deg",
-                ip_task_type=TaskName.solar_gain.value,
+                constant_name=CryonirspBudName.grating_position_deg,
+                metadata_key=CryonirspMetadataKey.grating_position_deg,
+                ip_task_types=[TaskName.observe, TaskName.solar_gain],
                 task_type_parsing_function=parse_header_ip_task_with_gains,
                 tolerance=0.01,
             ),
             TaskNearFloatBud(
-                constant_name=CryonirspBudName.grating_littrow_angle_deg.value,
-                metadata_key="grating_littrow_angle_deg",
-                ip_task_type=TaskName.solar_gain.value,
+                constant_name=CryonirspBudName.grating_littrow_angle_deg,
+                metadata_key=CryonirspMetadataKey.grating_littrow_angle_deg,
+                ip_task_types=[TaskName.observe, TaskName.solar_gain],
                 task_type_parsing_function=parse_header_ip_task_with_gains,
                 tolerance=0.01,
             ),
             TaskUniqueBud(
-                constant_name=CryonirspBudName.grating_constant.value,
-                metadata_key="grating_constant",
-                ip_task_type=TaskName.solar_gain.value,
+                constant_name=CryonirspBudName.grating_constant,
+                metadata_key=CryonirspMetadataKey.grating_constant,
+                ip_task_types=[TaskName.observe, TaskName.solar_gain],
                 task_type_parsing_function=parse_header_ip_task_with_gains,
             ),
             TaskUniqueBud(
-                constant_name=CryonirspBudName.wave_min.value,
-                metadata_key="wave_min",
-                ip_task_type=TaskName.solar_gain.value,
+                constant_name=CryonirspBudName.center_wavelength,
+                metadata_key=CryonirspMetadataKey.center_wavelength,
+                ip_task_types=[TaskName.observe, TaskName.solar_gain],
                 task_type_parsing_function=parse_header_ip_task_with_gains,
             ),
             TaskUniqueBud(
-                constant_name=CryonirspBudName.wave_max.value,
-                metadata_key="wave_max",
-                ip_task_type=TaskName.solar_gain.value,
+                constant_name=CryonirspBudName.slit_width,
+                metadata_key=CryonirspMetadataKey.slit_width,
+                ip_task_types=[TaskName.observe, TaskName.solar_gain],
                 task_type_parsing_function=parse_header_ip_task_with_gains,
             ),
             CheckLampGainFramesPickyBud(),
             CryonirspTaskExposureConditionsBud(
-                stem_name=CryonirspBudName.lamp_gain_exposure_conditions_list.value,
-                ip_task_type=TaskName.lamp_gain.value,
+                stem_name=CryonirspBudName.lamp_gain_exposure_conditions_list,
+                ip_task_type=TaskName.lamp_gain,
             ),
             CryonirspSPConditionalTaskExposureConditionsBud(),
             CryonirspSPPickyDarkExposureConditionsBud(),

dkist_processing_cryonirsp/tasks/quality_metrics.py

@@ -1,4 +1,5 @@
 """Cryonirsp quality metrics task."""
+
 from dataclasses import dataclass
 from dataclasses import field
 from typing import Generator
@@ -107,26 +108,26 @@ class CryonirspL1QualityMetrics(CryonirspTaskBase, QualityMixin):
     def run(self) -> None:
         """Calculate sensitivity and noise quality metrics."""
         if self.constants.correct_for_polarization:
-            with self.apm_processing_step(
-                "Calculating L1 Sensitivity metrics for all stokes states"
-            ):
+            with self.telemetry_span("Calculating L1 Sensitivity metrics for all stokes states"):
                 self.compute_full_stokes_sensitivity()
-            with self.apm_task_step("Calculating L1 Cryonirsp noise metrics for all stokes states"):
+            with self.telemetry_span(
+                "Calculating L1 Cryonirsp noise metrics for all stokes states"
+            ):
                 self.compute_full_stokes_noise()
         else:
-            with self.apm_processing_step("Calculating L1 Sensitivity metrics for intensity only"):
+            with self.telemetry_span("Calculating L1 Sensitivity metrics for intensity only"):
                 self.compute_intensity_only_sensitivity()
-            with self.apm_task_step("Calculating L1 Cryonirsp noise metrics for intensity only"):
+            with self.telemetry_span("Calculating L1 Cryonirsp noise metrics for intensity only"):
                 self.compute_intensity_only_noise()
 
     def compute_full_stokes_sensitivity(self):
         """Compute the sensitivities of each map scan for each stokes state."""
         for stokes_state in self.constants.stokes_params:
-            with self.apm_processing_step(f"Calculating sensitivity for stokes = {stokes_state}"):
+            with self.telemetry_span(f"Calculating sensitivity for stokes = {stokes_state}"):
                 quality_data = self.calculate_sensitivity_for_stokes_state(
                     stokes_state=stokes_state
                 )
-            with self.apm_writing_step(f"Writing sensitivity data for stokes = {stokes_state}"):
+            with self.telemetry_span(f"Writing sensitivity data for stokes = {stokes_state}"):
                 self.quality_store_sensitivity(
                     stokes=stokes_state,
                     datetimes=quality_data.datetimes,
@@ -135,9 +136,9 @@ class CryonirspL1QualityMetrics(CryonirspTaskBase, QualityMixin):
 
     def compute_intensity_only_sensitivity(self):
         """Compute the sensitivities of each map scan for the intensity stokes state only."""
-        with self.apm_processing_step(f"Calculating sensitivity for intensity only"):
+        with self.telemetry_span(f"Calculating sensitivity for intensity only"):
             quality_data = self.calculate_sensitivity_for_stokes_state(stokes_state="I")
-        with self.apm_writing_step("Writing sensitivity data for intensity only"):
+        with self.telemetry_span("Writing sensitivity data for intensity only"):
             self.quality_store_sensitivity(
                 stokes="I", datetimes=quality_data.datetimes, values=quality_data.values
             )
@@ -145,9 +146,9 @@ class CryonirspL1QualityMetrics(CryonirspTaskBase, QualityMixin):
     def compute_full_stokes_noise(self):
         """Compute noise in data broken down by each stokes state."""
         for stokes in self.constants.stokes_params:
-            with self.apm_processing_step(f"Compile noise values for {stokes=}"):
+            with self.telemetry_span(f"Compile noise values for {stokes=}"):
                 noise_data = self.compile_noise_data(stokes=stokes)
-            with self.apm_writing_step(f"Write noise values for {stokes=}"):
+            with self.telemetry_span(f"Write noise values for {stokes=}"):
                 self.quality_store_noise(
                     datetimes=noise_data.datetimes, values=noise_data.values, stokes=stokes
                 )
@@ -155,9 +156,9 @@ class CryonirspL1QualityMetrics(CryonirspTaskBase, QualityMixin):
     def compute_intensity_only_noise(self):
         """Compute noise in data for the intensity stokes state only."""
         stokes = "I"
-        with self.apm_processing_step(f"Compile noise values for {stokes=}"):
+        with self.telemetry_span(f"Compile noise values for {stokes=}"):
             noise_data = self.compile_noise_data(stokes=stokes)
-        with self.apm_writing_step(f"Write noise values for {stokes=}"):
+        with self.telemetry_span(f"Write noise values for {stokes=}"):
             self.quality_store_noise(
                 datetimes=noise_data.datetimes, values=noise_data.values, stokes=stokes
             )

dkist_processing_cryonirsp/tasks/science_base.py

@@ -1,4 +1,5 @@
 """Base frameworks for Cryonirsp science calibration."""
+
 from abc import ABC
 from abc import abstractmethod
 from collections.abc import Iterable
@@ -9,6 +10,7 @@ from astropy.io import fits
 from astropy.time import Time
 from astropy.time import TimeDelta
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
+from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_math.arithmetic import divide_arrays_by_array
 from dkist_processing_math.arithmetic import subtract_array_from_arrays
@@ -69,17 +71,17 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         None
 
         """
-        with self.apm_task_step("Loading calibration objects"):
+        with self.telemetry_span("Loading calibration objects"):
             calibrations = self.collect_calibration_objects()
 
-        with self.apm_task_step(
+        with self.telemetry_span(
             f"Calibrating Science Frames for "
             f"{self.constants.num_map_scans} map scans and "
             f"{self.constants.num_scan_steps} scan steps"
         ):
             self.calibrate_and_write_frames(calibrations=calibrations)
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_science_frames: int = self.scratch.count_all(
                 tags=[
                     CryonirspTag.linearized_frame(),
@@ -226,7 +228,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         array_stack = np.zeros(array_shape + (self.constants.num_modstates,))
         header_stack = []
 
-        with self.apm_processing_step(f"Correcting {self.constants.num_modstates} modstates"):
+        with self.telemetry_span(f"Correcting {self.constants.num_modstates} modstates"):
             for modstate in range(1, self.constants.num_modstates + 1):
                 # Correct the arrays
                 corrected_array, corrected_header = self.apply_basic_corrections(
@@ -242,7 +244,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
                 array_stack[:, :, modstate - 1] = corrected_array
                 header_stack.append(corrected_header)
 
-        with self.apm_processing_step("Applying instrument polarization correction"):
+        with self.telemetry_span("Applying instrument polarization correction"):
             intermediate_array = self.polarization_correction(
                 array_stack, calibrations.demod_matrices[CryonirspTag.beam(beam)]
             )
@@ -395,7 +397,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         date_end = (Time(sorted_obj_list[-1].time_obs) + exp_time).isot
 
         header = sorted_obj_list[0].header
-        header["DATE-BEG"] = date_beg
+        header[MetadataKey.time_obs] = date_beg
         header["DATE-END"] = date_end
 
         return header

dkist_processing_cryonirsp/tasks/sp_beam_boundaries.py

@@ -1,4 +1,5 @@
 """Cryonirsp SP beam boundaries task."""
+
 import math
 
 import numpy as np
@@ -6,9 +7,9 @@ from dkist_service_configuration.logging import logger
 
 from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundary
 from dkist_processing_cryonirsp.tasks.beam_boundaries_base import BeamBoundariesCalibrationBase
-from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import ShiftMeasurementsMixin
 from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import SPATIAL
 from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import SPECTRAL
+from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import ShiftMeasurementsMixin
 
 __all__ = ["SPBeamBoundariesCalibration"]
 

dkist_processing_cryonirsp/tasks/sp_geometric.py

@@ -1,4 +1,5 @@
 """Cryo SP geometric task."""
+
 import math
 
 import numpy as np
@@ -19,9 +20,9 @@ from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import (
     CryonirspLinearizedFitsAccess,
 )
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
-from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import ShiftMeasurementsMixin
 from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import SPATIAL
 from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import SPECTRAL
+from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import ShiftMeasurementsMixin
 
 __all__ = ["SPGeometricCalibration"]
 
@@ -70,39 +71,39 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
         """
         # The basic corrections are done outside the loop structure below as it makes these loops much
         # simpler than they would be otherwise. See the comments in do_basic_corrections for more details.
-        with self.apm_processing_step("Basic corrections"):
+        with self.telemetry_span("Basic corrections"):
             self.do_basic_corrections()
 
         for beam in range(1, self.constants.num_beams + 1):
-            with self.apm_task_step(f"Generating geometric calibrations for {beam = }"):
-                with self.apm_processing_step(f"Computing and writing angle for {beam = }"):
+            with self.telemetry_span(f"Generating geometric calibrations for {beam = }"):
+                with self.telemetry_span(f"Computing and writing angle for {beam = }"):
                     angle = self.compute_beam_angle(beam=beam)
                     self.write_angle(angle=angle, beam=beam)
 
-                with self.apm_processing_step(f"Removing angle from {beam = }"):
+                with self.telemetry_span(f"Removing angle from {beam = }"):
                     angle_corr_array = self.remove_beam_angle(angle=angle, beam=beam)
 
-                with self.apm_processing_step(f"Computing offset for {beam = }"):
+                with self.telemetry_span(f"Computing offset for {beam = }"):
                     beam_offset = self.compute_offset(
                         array=angle_corr_array,
                         beam=beam,
                     )
                     self.write_beam_offset(offset=beam_offset, beam=beam)
 
-                with self.apm_processing_step(f"Removing offset for {beam = }"):
+                with self.telemetry_span(f"Removing offset for {beam = }"):
                     self.remove_beam_offset(
                         array=angle_corr_array,
                         offset=beam_offset,
                         beam=beam,
                     )
 
-                with self.apm_processing_step(f"Computing spectral shifts for {beam = }"):
+                with self.telemetry_span(f"Computing spectral shifts for {beam = }"):
                     spec_shifts = self.compute_spectral_shifts(beam=beam)
 
-                with self.apm_writing_step(f"Writing spectral shifts for {beam = }"):
+                with self.telemetry_span(f"Writing spectral shifts for {beam = }"):
                     self.write_spectral_shifts(shifts=spec_shifts, beam=beam)
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_geo_frames: int = self.scratch.count_all(
                 tags=[
                     CryonirspTag.linearized_frame(),

dkist_processing_cryonirsp/tasks/sp_science.py

@@ -1,4 +1,5 @@
 """Cryo SP science calibration task."""
+
 from collections import defaultdict
 
 import numpy as np

dkist_processing_cryonirsp/tasks/sp_solar_gain.py

@@ -1,4 +1,5 @@
 """Cryo SP solar gain task."""
+
 import numpy as np
 import scipy.ndimage as spnd
 from dkist_processing_common.codecs.fits import fits_array_encoder
@@ -59,29 +60,31 @@ class SPSolarGainCalibration(CryonirspTaskBase):
         """
         target_exposure_conditions = self.constants.solar_gain_exposure_conditions_list
 
-        with self.apm_step(f"Computing SP gain calibrations for {target_exposure_conditions=}"):
+        with self.telemetry_span(
+            f"Computing SP gain calibrations for {target_exposure_conditions=}"
+        ):
             for exposure_conditions in target_exposure_conditions:
                 for beam in range(1, self.constants.num_beams + 1):
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Perform initial corrections for {beam = } and {exposure_conditions = }"
                     ):
                         spectral_corrected_solar_array = self.do_initial_corrections(
                             beam=beam, exposure_conditions=exposure_conditions
                         )
 
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Compute the characteristic spectrum for {beam = } and {exposure_conditions = }"
                     ):
                         char_spectrum = self.compute_char_spectrum(
                             array=spectral_corrected_solar_array, beam=beam
                         )
 
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Re-apply the spectral and geometric distortions for {beam = } and {exposure_conditions = }"
                     ):
                         distorted_char_spectrum = self.distort_char_spectrum(char_spectrum)
 
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Remove the solar spectrum for {beam = } and {exposure_conditions = }"
                     ):
                         # This is the final gain image, as we do not normalize
@@ -92,7 +95,7 @@ class SPSolarGainCalibration(CryonirspTaskBase):
                         )
 
                     if self.parameters.fringe_correction_on:
-                        with self.apm_processing_step(
+                        with self.telemetry_span(
                             f"Computing final solar gain based on fringe-corrected flux-scaled lamp gain for {beam = } and {exposure_conditions = }"
                         ):
                             # Compute a solar gain based on a fringe-corrected lamp gain
@@ -100,7 +103,7 @@ class SPSolarGainCalibration(CryonirspTaskBase):
                                 beam, exposure_conditions
                             )
 
-                    with self.apm_writing_step(
+                    with self.telemetry_span(
                         f"Writing the final solar gain array for {beam = } and {exposure_conditions = }"
                     ):
                         self.write_solar_gain_calibration(
@@ -108,7 +111,7 @@ class SPSolarGainCalibration(CryonirspTaskBase):
                             beam=beam,
                         )
 
-            with self.apm_processing_step("Computing and logging quality metrics"):
+            with self.telemetry_span("Computing and logging quality metrics"):
                 no_of_raw_solar_frames: int = self.scratch.count_all(
                     tags=[
                         CryonirspTag.linearized_frame(),
@@ -448,18 +451,18 @@ class SPSolarGainCalibration(CryonirspTaskBase):
         """
         apm_str = f"{beam = } and {exposure_conditions = }"
 
-        with self.apm_processing_step(f"Perform initial corrections for {apm_str}"):
+        with self.telemetry_span(f"Perform initial corrections for {apm_str}"):
             corrected_solar_array = self.do_dark_and_bad_pixel_corrections(
                 beam=beam, exposure_conditions=exposure_conditions
             )
 
-        with self.apm_processing_step(f"Compute the flux-scaled lamp gain for {apm_str}"):
+        with self.telemetry_span(f"Compute the flux-scaled lamp gain for {apm_str}"):
             scaled_lamp_array = self.compute_flux_scaled_lamp_gain(corrected_solar_array, beam)
 
-        with self.apm_processing_step(f"Apply spectral filtering for {apm_str}"):
+        with self.telemetry_span(f"Apply spectral filtering for {apm_str}"):
             filtered_lamp_array = self.apply_spectral_and_spatial_filtering(scaled_lamp_array)
 
-        with self.apm_processing_step(f"Isolate and remove fringes for {apm_str}"):
+        with self.telemetry_span(f"Isolate and remove fringes for {apm_str}"):
             final_gain_array = self.isolate_and_remove_fringes(
                 filtered_lamp_array, scaled_lamp_array
             )