dkist-processing-common 13.0.2__tar.gz → 13.0.3rc2__tar.gz

{dkist_processing_common-13.0.2 → dkist_processing_common-13.0.3rc2}/CHANGELOG.rst

@@ -1,12 +1,3 @@
-v13.0.2 (2026-04-08)
-====================
-
-Misc
-----
-
-- Upgrade `dkist-processing-core` to version 7.2.0 which includes an `apache-airflow` version upgrade to 3.2.0. (`#325 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/325>`__)
-
-
 v13.0.1 (2026-04-07)
 ====================
 

{dkist_processing_common-13.0.2 → dkist_processing_common-13.0.3rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-common
-Version: 13.0.2
+Version: 13.0.3rc2
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause
@@ -17,7 +17,7 @@ Requires-Dist: asdf<4.0.0,>=3.5.0
 Requires-Dist: astropy>=7.0.0
 Requires-Dist: dkist-fits-specifications<5.0,>=4.24.0
 Requires-Dist: dkist-header-validator<6.0,>=5.3.0
-Requires-Dist: dkist-processing-core==7.2.0
+Requires-Dist: dkist-processing-core==7.1.0
 Requires-Dist: dkist-processing-pac<4.0,>=3.1
 Requires-Dist: dkist-service-configuration<5.0,>=4.3.0
 Requires-Dist: dkist-spectral-lines<4.0,>=3.0.0

dkist_processing_common-13.0.3rc2/changelog/326.feature.rst

@@ -0,0 +1 @@
+Simplify the production of L1 quality metrics.

{dkist_processing_common-13.0.2 → dkist_processing_common-13.0.3rc2}/dkist_processing_common/models/quality.py

@@ -13,7 +13,6 @@ from pydantic import PlainSerializer
 from pydantic import field_validator
 from pydantic import model_serializer
 from pydantic import model_validator
-from pydantic.alias_generators import to_camel
 from pydantic_core.core_schema import SerializationInfo
 from pydantic_core.core_schema import ValidationInfo
 
@@ -276,7 +275,7 @@ class TableData(QualityModel):
     # Note: numeric values are represented as strings for table data
     rows: tuple[tuple[str, ...], ...]
     header_row: bool | None = True
-    header_col: bool | None = False
+    header_column: bool | None = False
 
     @model_validator(mode="after")
     def tuple_validation(self):

{dkist_processing_common-13.0.2 → dkist_processing_common-13.0.3rc2}/dkist_processing_common/parsers/quality.py

@@ -31,5 +31,5 @@ class L1QualityFitsAccess(L1FitsAccess):
         self.date_begin: str = self.header["DATE-BEG"]
         self.light_level: float = self.header["LIGHTLVL"]
         self.health_status: str = self.header["DSHEALTH"]
-        self.ao_status: int = self.header.get("AO_LOCK", None)
-        self.num_out_of_bounds_ao_values: int = self.header.get("OOBSHIFT", None)
+        self.ao_status: int | None = self.header.get("AO_LOCK", None)
+        self.num_out_of_bounds_ao_values: int | None = self.header.get("OOBSHIFT", None)

{dkist_processing_common-13.0.2 → dkist_processing_common-13.0.3rc2}/dkist_processing_common/tasks/mixin/quality/_base.py

@@ -66,14 +66,10 @@ class QualityMixin(
     def quality_metrics_no_task_dependence(self) -> dict:
         """Return a dict of the quality metrics with no task dependence."""
         return {
-            "FRIED_PARAMETER": self.quality_build_fried_parameter,
-            "LIGHT_LEVEL": self.quality_build_light_level,
             "NOISE": self.quality_build_noise,
             "SENSITIVITY": self.quality_build_sensitivity,
-            "HEALTH_STATUS": self.quality_build_health_status,
             "TASK_TYPES": self.quality_build_task_type_counts,
             "HISTORICAL": self.quality_build_historical,
-            "AO_STATUS": self.quality_build_ao_status,
             "RANGE": self.quality_build_range,
             "WAVECAL_FIT": self.quality_build_wavecal_results,
         }

{dkist_processing_common-13.0.2 → dkist_processing_common-13.0.3rc2}/dkist_processing_common/tasks/mixin/quality/_metrics.py

@@ -25,7 +25,6 @@ from pandas import DataFrame
 from solar_wavelength_calibration.fitter.wavelength_fitter import FitResult
 
 from dkist_processing_common.codecs.json import json_decoder
-from dkist_processing_common.models.fried_parameter import r0_valid
 from dkist_processing_common.models.metric_code import MetricCode
 from dkist_processing_common.models.quality import EfficiencyHistograms
 from dkist_processing_common.models.quality import ModulationMatrixHistograms
@@ -41,24 +40,6 @@ logger = logging.getLogger(__name__)
 
 
 class _SimpleQualityMixin:
-    @staticmethod
-    def _create_statement_metric(
-        name: str,
-        description: str,
-        metric_code: str,
-        statement: str,
-        warnings: str | None = None,
-        facet: str | None = None,
-    ) -> dict:
-        metric = ReportMetric(
-            name=name,
-            description=description,
-            metric_code=metric_code,
-            facet=facet,
-            statement=statement,
-            warnings=warnings,
-        )
-        return metric.model_dump()
 
     def quality_store_range(self, name: str, warnings: list[str]):
         """
@@ -209,111 +190,6 @@ class _SimplePlotQualityMixin:
                 )
         return warnings
 
-    def quality_store_ao_status_and_fried_parameter(
-        self, datetimes: list[str], values: list[list[bool | float]]
-    ):
-        """
-        Collect and store datetime / value pairs for the boolean AO status and Fried parameter.
-
-        Store all non-None AO lock status values, but only store Fried parameter values if AO lock status is True.
-
-        Because of how L1Metric.has_metric works, empty lists will not be passed to this method.
-        However, because of how L1Metric.store_metric works, one or both values can be None.
-        """
-        ao_lock_values = [value[0] for value in values]
-        ao_not_none = [ao for ao in ao_lock_values if ao is not None]
-        if len(ao_not_none) != 0:
-            self._record_values(values=ao_not_none, tags=Tag.quality(MetricCode.ao_status))
-        fried_values = [value[1] for value in values]
-        ao_oob_values = [value[2] for value in values]
-        fried_values_to_plot = []
-        datetimes_to_plot = []
-        # For each set of input data, check if the r0 is considered valid based on all data
-        for i in range(len(fried_values)):
-            if r0_valid(
-                r0=fried_values[i],
-                ao_lock=ao_lock_values[i],
-                num_out_of_bounds_ao_values=ao_oob_values[i],
-            ):
-                fried_values_to_plot.append(fried_values[i])
-                datetimes_to_plot.append(datetimes[i])
-        if len(fried_values_to_plot) != 0:
-            self._record_2d_plot_values(
-                x_values=datetimes_to_plot,
-                y_values=fried_values_to_plot,
-                tags=Tag.quality(MetricCode.fried_parameter),
-            )
-
-    def quality_build_ao_status(self) -> dict:
-        """
-        Build ao status schema from stored data.
-
-        Because of how quality_task_independent_metrics in the QualityMixin works, this method is not called if no data is on disk.
-        """
-        ao_status = []
-        # Loop over files that contain data for this metric
-        for path in self.read(tags=Tag.quality(MetricCode.ao_status)):
-            with path.open() as f:
-                ao_status += json.load(f)
-        percentage = round(100 * np.count_nonzero(ao_status) / len(ao_status), 1)
-        return self._create_statement_metric(
-            name="Adaptive Optics Status",
-            description="This metric shows the percentage of frames in which the adaptive optics "
-            "system was running and locked",
-            metric_code=MetricCode.ao_status,
-            statement=f"The adaptive optics system was running and locked for {percentage}% of the "
-            f"observed frames",
-            warnings=None,
-        )
-
-    def quality_build_fried_parameter(self) -> dict:
-        """
-        Build fried parameter schema from stored data.
-
-        Because of how quality_task_independent_metrics in the QualityMixin works, this method is not called if no data is on disk.
-        """
-        # Merge all recorded quality values
-        series_data = self._load_2d_plot_values(tags=Tag.quality(MetricCode.fried_parameter))
-        values = list(series_data.values())[0][1]
-        return self._create_2d_plot_with_datetime_metric(
-            name="Fried Parameter",
-            description="This metric quantifies the stability of the atmosphere during an "
-            "observation and directly impacts the data quality through a phenomenon "
-            "known as atmospheric seeing. One measurement is taken per L1 frame. "
-            "Only measurements taken while the AO system is locked are valid.",
-            metric_code=MetricCode.fried_parameter,
-            xlabel="Time",
-            ylabel="Fried Parameter (m)",
-            ylim=(0.0, 0.2),
-            series_data=series_data,
-            statement=f"Average valid Fried Parameter measurements for L1 dataset: "
-            f"{round(np.mean(values), 2)} ± {round(np.std(values), 2)} m",
-            warnings=None,
-        )
-
-    def quality_store_light_level(self, datetimes: list[str], values: list[float]):
-        """Collect and store datetime / value pairs for the light level."""
-        self._record_2d_plot_values(
-            x_values=datetimes, y_values=values, tags=Tag.quality(MetricCode.light_level)
-        )
-
-    def quality_build_light_level(self) -> dict:
-        """Build light_level schema from stored data."""
-        series_data = self._load_2d_plot_values(tags=Tag.quality(MetricCode.light_level))
-        values = list(series_data.values())[0][1]
-        return self._create_2d_plot_with_datetime_metric(
-            name="Light Level",
-            description="The telescope light level, as measured by the Telescope Acquisition Camera, at the start of "
-            "data acquisition of each frame.",
-            metric_code=MetricCode.light_level,
-            xlabel="Time",
-            ylabel="Light Level (adu)",
-            series_data=series_data,
-            statement=f"Average Light Level for L1 dataset: "
-            f"{round(np.mean(values), 2)} ± {round(np.std(values), 2)} adu",
-            warnings=None,
-        )
-
     def quality_store_noise(self, datetimes: list[str], values: list[float], stokes: str = "I"):
         """Collect and store datetime / value pairs for the noise data."""
         self._record_2d_plot_values(
@@ -390,43 +266,6 @@ class _TableQualityMixin:
         )
         return metric.model_dump()
 
-    def quality_store_health_status(self, values: list[str]):
-        """
-        Collect and store health status data.
-
-        Parameters
-        ----------
-        values: statuses as listed in the headers
-        """
-        self._record_values(values=values, tags=Tag.quality(MetricCode.health_status))
-
-    def quality_build_health_status(self) -> dict:
-        """Build health status schema from stored data."""
-        values = []
-        for path in self.read(tags=Tag.quality(MetricCode.health_status)):
-            with path.open() as f:
-                data = json.load(f)
-                values += data
-        statuses, counts = np.unique(values, return_counts=True)
-        statuses = [s.lower() for s in statuses]
-        # JSON serialization does not work with numpy types
-        counts = [int(c) for c in counts]
-        warnings = []
-        if any(s in statuses for s in ["bad", "ill", "unknown"]):
-            warnings.append(
-                "Data sourced from components with a health status of 'ill', 'bad', or 'unknown'."
-            )
-        table_data = [list(z) for z in zip(statuses, counts)]
-        table_data.insert(0, ["Status", "Count"])
-        return self._create_table_metric(
-            name="Data Source Health",
-            description="This metric contains the worst health status of the data source during "
-            "data acquisition. One reading is taken per L1 frame.",
-            metric_code=MetricCode.health_status,
-            rows=table_data,
-            warnings=self._format_warnings(warnings),
-        )
-
     def quality_store_task_type_counts(
         self, task_type: str, total_frames: int, frames_not_used: int = 0
     ):

{dkist_processing_common-13.0.2 → dkist_processing_common-13.0.3rc2}/dkist_processing_common/tasks/quality_metrics.py

@@ -3,19 +3,20 @@
 import logging
 from collections import defaultdict
 from datetime import datetime
-from inspect import signature
 from itertools import chain
 from pathlib import Path
-from typing import Callable
 from typing import Generator
 from typing import Iterable
 from typing import Type
 
 import numpy as np
 from pydantic import FiniteFloat
+from pydantic import model_validator
 
 from dkist_processing_common.codecs.basemodel import basemodel_encoder
+from dkist_processing_common.codecs.fits import fits_access_decoder
 from dkist_processing_common.models.fits_access import FitsAccessBase
+from dkist_processing_common.models.fried_parameter import r0_valid
 from dkist_processing_common.models.metric_code import MetricCode
 from dkist_processing_common.models.quality import QualityMetric
 from dkist_processing_common.models.quality import QualityModel
@@ -261,11 +262,6 @@ class QualityL0Metrics(WorkflowTaskBase, QualityMixin):
             metric_code=MetricCode.dataset_average,
             table_data=[table_data],
         )
-        # NOTE 1: QualityValueEncoder
-        # NOTE 1: a BaseModel float field automatically converts np.float32 to python float
-        # NOTE 2: QualityDataEncoder
-        # NOTE 2: a BaseModel datetime field automatically converts to iso 8601 str with mode="json"
-        # NOTE 2: a BaseModel FiniteFloat field inherently rejects `nan` and `inf` values
         self.write(metric, tags=Tag.quality("GENERIC"), encoder=basemodel_encoder)
 
     def compute_and_write_dataset_rms(
@@ -291,11 +287,6 @@ class QualityL0Metrics(WorkflowTaskBase, QualityMixin):
             metric_code=MetricCode.dataset_rms,
             table_data=[table_data],
         )
-        # NOTE 1: QualityValueEncoder
-        # NOTE 1: a BaseModel float field automatically converts np.float32 to python float
-        # NOTE 2: QualityDataEncoder
-        # NOTE 2: a BaseModel datetime field automatically converts to iso 8601 str with mode="json"
-        # NOTE 2: a BaseModel FiniteFloat field inherently rejects `nan` and `inf` values
         self.write(metric, tags=Tag.quality("GENERIC"), encoder=basemodel_encoder)
 
     def compute_and_write_frame_average(
@@ -341,12 +332,6 @@ class QualityL0Metrics(WorkflowTaskBase, QualityMixin):
                 plot_data=[xy_data],
                 warnings=warnings,
             )
-            # NOTE 1: QualityValueEncoder
-            # NOTE 1: a BaseModel float field automatically converts np.float32 to python float
-            # NOTE 2: QualityDataEncoder
-            # NOTE 2: a BaseModel datetime field automatically converts to iso 8601 str with mode="json"
-            # NOTE 2: a BaseModel FiniteFloat field inherently rejects `nan` and `inf` values
-            # write one file per task type
             self.write(metric, tags=Tag.quality("GENERIC"), encoder=basemodel_encoder)
 
     def compute_and_write_frame_rms(
@@ -392,112 +377,252 @@ class QualityL0Metrics(WorkflowTaskBase, QualityMixin):
                 plot_data=[xy_data],
                 warnings=warnings,
             )
-            # NOTE 1: QualityValueEncoder
-            # NOTE 1: a BaseModel float field automatically converts np.float32 to python float
-            # NOTE 2: QualityDataEncoder
-            # NOTE 2: a BaseModel datetime field automatically converts to iso 8601 str with mode="json"
-            # NOTE 2: a BaseModel FiniteFloat field inherently rejects `nan` and `inf` values
-            # write one file per task type
             self.write(metric, tags=Tag.quality("GENERIC"), encoder=basemodel_encoder)
 
 
-class L1Metric:
-    """
-    Class for collecting L1 quality metric data while frames are being opened before storing on disk.
-
-    Parameters
-    ----------
-    storage_method
-        The callable used to execute the storage
-    value_source
-        The source of the value being stored
-    value_function
-        The function to return the values
-    """
+class L1QualityData(QualityModel):
+    """Intermediate L1 Quality Data gleaned from collection of L1QualityFitsAccess."""
 
-    def __init__(
-        self,
-        storage_method: Callable,
-        value_source: list[str] | str,
-        value_function: Callable | None = None,
-    ):
-        self.storage_method = storage_method
-        self.value_source = value_source
-        self.values = []
-        self.datetimes = []
-        self.value_function = value_function
-
-    def append_value(self, frame: L1QualityFitsAccess) -> None:
-        """
-        Append datetime from the frame to the list of datetimes.
+    # by default, a tuple accepts a list as input
+    # the use of tuples is intentional because list mutations do not trigger validation
+    # the impact is that L1QualityData should not be instantiated until
+    # after the tuple input has been fully accumulated
+    # when `mode="json"`, the output of a tuple results in a list
+    # when `mode="python"`, the output of a tuple results in a tuple
+    datetimes: tuple[datetime, ...]
+    # NOTE:  FiniteFloat will fail fast for `nan` and `inf`
+    light_level_values: tuple[FiniteFloat, ...]
+    health_status_values: tuple[str, ...]
+    # NOTE:  FiniteFloat will fail fast for `nan` and `inf`
+    fried_parameter_values: tuple[FiniteFloat, ...]
+    ao_lock_values: tuple[bool | None, ...]
+    ao_oob_values: tuple[int | None, ...]
+
+    @model_validator(mode="after")
+    def tuple_validation(self):
+        """Validate tuple lengths."""
+        error_message = [f"{len(self.datetimes)=}"]
+        datetime_len = len(self.datetimes)
+        if len(self.light_level_values) != datetime_len:
+            error_message.append(f"{len(self.light_level_values)=}")
+        if len(self.health_status_values) != datetime_len:
+            error_message.append(f"{len(self.health_status_values)=}")
+        if len(self.fried_parameter_values) != datetime_len:
+            error_message.append(f"{len(self.fried_parameter_values)=}")
+        if len(self.ao_lock_values) != datetime_len:
+            error_message.append(f"{len(self.ao_lock_values)=}")
+        if len(self.ao_oob_values) != datetime_len:
+            error_message.append(f"{len(self.ao_oob_values)=}")
+        if len(error_message) > 1:
+            raise ValueError(
+                f"One or more dimensions have wrong length: {', '.join(error_message)}. "
+            )
+        return self
 
-        If a value_function was provided, apply it to the given source attribute and append to
-        self.values. Otherwise, append the attribute value itself to self.values.  If multiple
-        sources provided, append a list of the source attributes to self.values.
 
-        Parameters
-        ----------
-        frame
-            The input frame
+class QualityL1Metrics(WorkflowTaskBase, QualityMixin):
+    """Task class supporting the generation of quality metrics for the L1 data."""
 
-        Returns
-        -------
-        None
-        """
-        self.datetimes.append(frame.time_obs)
-        if self.value_function:
-            self.values.append(self.value_function(getattr(frame, self.value_source)))
+    def run(self) -> None:
+        """Run method for this task."""
+        with self.telemetry_span("Reading L1 frames"):
+            l1_quality_data = self.collect_l1_quality_data()
+
+        with self.telemetry_span("Writing L1 quality data"):
+            self.compute_and_write_l1_quality_metrics(l1_quality_data)
+
+    def collect_l1_quality_data(self) -> L1QualityData:
+        """Collect data used to compute L1 quality metrics."""
+        frames = self.read(
+            tags=[Tag.calibrated(), Tag.frame()],
+            decoder=fits_access_decoder,
+            fits_access_class=L1QualityFitsAccess,
+        )
+
+        # accumulate specified L1QualityFitsAccess values into lists, sorted by datetime
+        rows = sorted(
+            (
+                (
+                    # DATE-BEG
+                    datetime.fromisoformat(frame.time_obs),
+                    # LIGHTLVL
+                    frame.light_level,
+                    # DSHEALTH
+                    frame.health_status,
+                    # ATMOS_R0
+                    frame.fried_parameter,
+                    # AO_LOCK
+                    frame.ao_status,
+                    # OOBSHIFT
+                    frame.num_out_of_bounds_ao_values,
+                )
+                for frame in frames
+            ),
+            # DATE-BEG
+            key=lambda row: row[0],
+        )
+
+        return L1QualityData(
+            datetimes=tuple(row[0] for row in rows),
+            light_level_values=tuple(row[1] for row in rows),
+            health_status_values=tuple(row[2] for row in rows),
+            fried_parameter_values=tuple(row[3] for row in rows),
+            ao_lock_values=tuple(row[4] for row in rows),
+            ao_oob_values=tuple(row[5] for row in rows),
+        )
+
+    def compute_and_write_l1_quality_metrics(self, l1_quality_data: L1QualityData) -> None:
+        """Write L1 metrics to disk."""
+        self.compute_and_write_ao_status(l1_quality_data)
+        self.compute_and_write_fried_parameter(l1_quality_data)
+        self.compute_and_write_health_status(l1_quality_data)
+        self.compute_and_write_light_level(l1_quality_data)
+
+    def compute_and_write_ao_status(self, l1_quality_data: L1QualityData) -> None:
+        """Write AO_STATUS quality metric."""
+        ao_not_none = [ao for ao in l1_quality_data.ao_lock_values if ao is not None]
+
+        # don't write anything if there is no data
+        if not ao_not_none:
             return
-        if isinstance(self.value_source, list):
-            multiple_values = [getattr(frame, source, None) for source in self.value_source]
-            self.values.append(multiple_values)
+
+        percentage = round(100 * np.count_nonzero(ao_not_none) / len(ao_not_none), 1)
+
+        metric = QualityMetric(
+            name="Adaptive Optics Status",
+            description="This metric shows the percentage of frames in which the adaptive optics "
+            "system was running and locked",
+            metric_code=MetricCode.ao_status,
+            statement=[
+                f"The adaptive optics system was running and locked for {percentage}% of the observed frames"
+            ],
+        )
+
+        self.write(metric, tags=Tag.quality("GENERIC"), encoder=basemodel_encoder)
+
+    def compute_and_write_fried_parameter(self, l1_quality_data: L1QualityData) -> None:
+        """Write FRIED_PARAMETER quality metric."""
+        datetimes = l1_quality_data.datetimes
+        fried_parameter_values = l1_quality_data.fried_parameter_values
+        ao_lock_values = l1_quality_data.ao_lock_values
+        ao_oob_values = l1_quality_data.ao_oob_values
+
+        fried_values_to_plot = []
+        datetimes_to_plot = []
+        # For each set of input data, check if the r0 is considered valid based on all data
+        for i in range(len(fried_parameter_values)):
+            if r0_valid(
+                r0=fried_parameter_values[i],
+                ao_lock=ao_lock_values[i],
+                num_out_of_bounds_ao_values=ao_oob_values[i],
+            ):
+                datetimes_to_plot.append(datetimes[i])
+                fried_values_to_plot.append(fried_parameter_values[i])
+
+        if len(fried_values_to_plot) == 0:
+            # don't write anything if there is no data
             return
-        self.values.append(getattr(frame, self.value_source))
 
-    @property
-    def has_values(self):
-        return len(self.values) > 0
-
-    def store_metric(self):
-        """Remove None values from a single-value values list (and also remove corresponding indices from datetimes) then send to the provided storage method."""
-        # Get indices of non-None values and only use those.
-        # Use multi-valued lists as is to be handled in the applicable storage_method.
-        indices = [i for i, val in enumerate(self.values) if val is not None]
-        d = [self.datetimes[i] for i in indices]
-        v = [self.values[i] for i in indices]
-        # Get signature of storage method and call with applicable args
-        storage_method_sig = signature(self.storage_method)
-        if storage_method_sig.parameters.get("datetimes", False):
-            self.storage_method(datetimes=d, values=v)
+        time_series = TimeSeriesData(
+            x_values=tuple(datetimes_to_plot),
+            y_values=tuple(fried_values_to_plot),
+        )
+
+        series_data = {"": time_series}
+
+        xy_data = XYData(
+            xlabel="Time",
+            ylabel="Fried Parameter (m)",
+            ylim=(0.0, 0.2),
+            series_data=series_data,
+        )
+
+        statement = (
+            f"Average valid Fried Parameter measurements for L1 dataset: "
+            f"{round(np.mean(fried_values_to_plot), 2)} ± {round(np.std(fried_values_to_plot), 2)} m"
+        )
+
+        metric = QualityMetric(
+            name="Fried Parameter",
+            description="This metric quantifies the stability of the atmosphere during an "
+            "observation and directly impacts the data quality through a phenomenon "
+            "known as atmospheric seeing. One measurement is taken per L1 frame. "
+            "Only measurements taken while the AO system is locked are valid.",
+            metric_code=MetricCode.fried_parameter,
+            plot_data=[xy_data],
+            statement=[statement],
+        )
+
+        self.write(metric, tags=Tag.quality("GENERIC"), encoder=basemodel_encoder)
+
+    def compute_and_write_health_status(self, l1_quality_data: L1QualityData) -> None:
+        """Write HEALTH_STATUS quality metric."""
+        # don't need to check for None -  l1_quality_data.health_status_values does not allow None
+        health_status_values = l1_quality_data.health_status_values
+
+        # don't write anything if there is no data
+        if not health_status_values:
             return
-        self.storage_method(values=v)
 
+        statuses, counts = np.unique(health_status_values, return_counts=True)
+        # individual elements to lower case, with side effect of switch from numpy.ndarray to list
+        statuses = [s.lower() for s in statuses]
+        # individual elements from int to str, with side effect of switch from numpy.ndarray to list
+        counts = [str(c) for c in counts]
 
-class QualityL1Metrics(WorkflowTaskBase, QualityMixin):
-    """Task class supporting the generation of quality metrics for the L0 data."""
+        header = ("Status", "Count")
+        rows = [header]
+        rows.extend(tuple(z) for z in zip(statuses, counts))
+        table_data = TableData(rows=tuple(rows))
 
-    def run(self) -> None:
-        """Run method for this task."""
-        metrics = [
-            L1Metric(storage_method=self.quality_store_light_level, value_source="light_level"),
-            L1Metric(storage_method=self.quality_store_health_status, value_source="health_status"),
-            L1Metric(
-                storage_method=self.quality_store_ao_status_and_fried_parameter,
-                value_source=["ao_status", "fried_parameter", "num_out_of_bounds_ao_values"],
-            ),
-        ]
+        metric = QualityMetric(
+            name="Data Source Health",
+            description="This metric contains the worst health status of the data source during "
+            "data acquisition. One reading is taken per L1 frame.",
+            metric_code=MetricCode.health_status,
+            table_data=[table_data],
+        )
 
-        with self.telemetry_span("Reading L1 frames"):
-            paths = list(self.read(tags=[Tag.calibrated(), Tag.frame()]))
+        if any(s in statuses for s in ["bad", "ill", "unknown"]):
+            metric.warnings = [
+                "Data sourced from components with a health status of 'ill', 'bad', or 'unknown'."
+            ]
 
-        with self.telemetry_span("Calculating L1 quality metrics"):
-            for metric in metrics:
-                with self.telemetry_span(f"Calculating L1 metric {metric.value_source}"):
-                    for path in paths:
-                        frame = L1QualityFitsAccess.from_path(path)
-                        metric.append_value(frame=frame)
+        self.write(metric, tags=Tag.quality("GENERIC"), encoder=basemodel_encoder)
+
+    def compute_and_write_light_level(self, l1_quality_data: L1QualityData) -> None:
+        """Write LIGHT_LEVEL quality metric."""
+        # don't need to check for None -  l1_quality_data.light_level_values does not allow None
+        datetimes = l1_quality_data.datetimes
+        light_level_values = l1_quality_data.light_level_values
+
+        # don't write anything if there is no data
+        if not light_level_values:
+            return
+
+        time_series = TimeSeriesData(
+            x_values=datetimes,
+            y_values=light_level_values,
+        )
+
+        series_data = {"": time_series}
+
+        xy_data = XYData(
+            xlabel="Time",
+            ylabel="Light Level (adu)",
+            series_data=series_data,
+        )
+
+        statement = f"Average Light Level for L1 dataset: "
+        f"{round(np.mean(light_level_values), 2)} ± {round(np.std(light_level_values), 2)} adu"
 
-        with self.telemetry_span("Sending lists for storage"):
-            for metric in metrics:
-                if metric.has_values:
-                    metric.store_metric()
+        metric = QualityMetric(
+            name="Light Level",
+            description="The telescope light level, as measured by the Telescope Acquisition Camera, "
+            "at the start of data acquisition of each frame.",
+            metric_code=MetricCode.light_level,
+            plot_data=[xy_data],
+            statement=[statement],
+        )
+
+        self.write(metric, tags=Tag.quality("GENERIC"), encoder=basemodel_encoder)