dkist-processing-common 12.9.0__tar.gz → 12.10.0__tar.gz

{dkist_processing_common-12.9.0 → dkist_processing_common-12.10.0}/CHANGELOG.rst

@@ -1,3 +1,14 @@
+v12.10.0 (2026-04-02)
+=====================
+
+Features
+--------
+
+- Added capabilities to simplify the way that quality metrics get produced.
+  The central feature is the `QualityMetric` `BaseModel` which can be used to fully define any quality metric. (`#313 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/313>`__)
+- Simplify the production of L0 quality metrics. (`#313 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/313>`__)
+
+
 v12.9.0 (2026-04-01)
 ====================
 

{dkist_processing_common-12.9.0 → dkist_processing_common-12.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-common
-Version: 12.9.0
+Version: 12.10.0
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause

dkist_processing_common-12.10.0/dkist_processing_common/models/quality.py

@@ -0,0 +1,351 @@
+"""Support classes used to create a quality report."""
+
+from datetime import datetime
+from typing import Annotated
+from typing import Any
+
+from pydantic import BaseModel
+from pydantic import BeforeValidator
+from pydantic import ConfigDict
+from pydantic import Field
+from pydantic import FiniteFloat
+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
+
+###########################################################
+# Old Quality Models                                      #
+#                                                         #
+# These will gradually be replaced by                    #
+# New Quality Models (below)                              #
+###########################################################
+
+
+class Plot2D(BaseModel):
+    """Support class use to hold the data for creating a 2D plot in the quality report."""
+
+    xlabel: str
+    ylabel: str
+    series_data: dict[str, list[list[Any]]]
+    series_name: str | None = None
+    ylabel_horizontal: bool = False
+    ylim: tuple[float, float] | None = None
+    plot_kwargs: dict[str, dict[str, Any]] = Field(default_factory=dict)
+    sort_series: bool = True
+
+
+class VerticalMultiPanePlot2D(BaseModel):
+    """
+    Support class to hold a multi-pane plot with plots stacked vertically.
+
+    This type of metric is really geared towards plots that share an X axis and have no gap between them. If you just
+    want two separate plots it's probably better to use a list of `Plot2D` objects.
+    """
+
+    top_to_bottom_plot_list: list[Plot2D]
+    match_x_axes: bool = True
+    no_gap: bool = True
+    top_to_bottom_height_ratios: list[float] | None = None
+
+    @field_validator("top_to_bottom_height_ratios")
+    @classmethod
+    def ensure_same_number_of_height_ratios_and_plots(
+        cls, height_ratios: list[float] | None, info: ValidationInfo
+    ) -> list[float]:
+        """
+        Make sure that the number of height ratios is the same as the number of plots.
+
+        Also populates default, same-size ratios if no ratios were given.
+        """
+        try:
+            plot_list = info.data["top_to_bottom_plot_list"]
+        except KeyError:
+            # The plot list didn't validate for some reason. We're about to error anyway.
+            return [1.0]
+
+        num_plots = len(plot_list)
+        if height_ratios is None:
+            return [1.0] * num_plots
+
+        if len(height_ratios) != num_plots:
+            raise ValueError(
+                f"The number of items in `top_to_bottom_height_ratios` list ({len(height_ratios)}) is not "
+                f"the same as the number of plots ({num_plots})"
+            )
+
+        return height_ratios
+
+
+class SimpleTable(BaseModel):
+    """Support class to hold a simple table to be inserted into the quality report."""
+
+    rows: list[list[Any]]
+    header_row: bool = True
+    header_column: bool = False
+
+
+class ModulationMatrixHistograms(BaseModel):
+    """Support class for holding the big ol' grid of histograms that represent the modulation matrix fits."""
+
+    modmat_list: list[list[list[float]]]
+
+
+class EfficiencyHistograms(BaseModel):
+    """Support class for holding 4 histograms that correspond to efficiencies of the 4 stokes components."""
+
+    efficiency_list: list[list[float]]
+
+
+class PlotHistogram(BaseModel):
+    """Support class to hold 1D data for plotting a histogram."""
+
+    xlabel: str
+    series_data: dict[str, list[float]]
+    series_name: str | None = None
+    vertical_lines: dict[str, float] | None
+
+
+class PlotRaincloud(BaseModel):
+    """Support class to hold data series for fancy-ass violin plots."""
+
+    xlabel: str
+    ylabel: str
+    categorical_column_name: str
+    distribution_column_name: str
+    dataframe_json: str
+    hue_column_name: str | None
+    ylabel_horizontal: bool | None
+
+
+class ReportMetric(BaseModel):
+    """A Quality Report is made up of a list of metrics with the schema defined by this class."""
+
+    name: str
+    description: str
+    metric_code: str
+    facet: str | None = None
+    statement: str | list[str] | None = None
+    plot_data: Plot2D | list[Plot2D] | None = None
+    multi_plot_data: VerticalMultiPanePlot2D | None = None
+    histogram_data: PlotHistogram | list[PlotHistogram] | None = None
+    table_data: SimpleTable | list[SimpleTable] | None = None
+    modmat_data: ModulationMatrixHistograms | None = None
+    efficiency_data: EfficiencyHistograms | None = None
+    raincloud_data: PlotRaincloud | None = None
+    warnings: list[str] | None = None
+
+
+###########################################################
+# New Quality Models                                      #
+#                                                         #
+# These define the interface with dkist-quality           #
+# These will eventually get moved to dkist-quality        #
+###########################################################
+
+
+class QualityModel(BaseModel):
+    """BaseModel for quality data."""
+
+    model_config = ConfigDict(
+        # only accept snake_case field names
+        validate_by_name=True,
+        # re-validate the field if its value gets changed after creation
+        validate_assignment=True,
+    )
+
+
+def datetime_or_iso_dict_input(v: Any) -> Any:
+    """
+    Extend pydantic `datetime` capability.
+
+    Adds the ability to accept an 'iso dict' of the {"iso_date": <value>} form
+    """
+    # If appropriate, extract value from {"iso_date": <value>} before passing to the normal datetime handler
+    if isinstance(v, dict) and "iso_date" in v:
+        return v["iso_date"]
+    return v
+
+
+# NOTE:  This is a temporary data type that can be eliminated once all metric conversion is complete
+DatetimeIsoDict = Annotated[
+    # this is a datetime within the pydantic BaseModel
+    datetime,
+    # accept 'iso dict' input in addition to normal datetime inputs
+    BeforeValidator(datetime_or_iso_dict_input),
+    # always output the datetime as an 'iso dict'
+    PlainSerializer(lambda dt: {"iso_date": dt.isoformat()}, return_type=dict[str, str]),
+]
+
+
+class TimeSeriesData(QualityModel):
+    """
+    Time Series Data.
+
+    The context, e.g. task_type or modstate, is maintained outside of this structure.
+    """
+
+    # 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 TimeSeriesData 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
+    x_values: tuple[DatetimeIsoDict, ...]
+    # NOTE:  FiniteFloat will fail fast for `nan` and `inf`
+    y_values: tuple[FiniteFloat, ...]
+
+    @model_validator(mode="after")
+    def tuple_validation(self):
+        """Validate tuple lengths."""
+        axes_are_different_lengths = len(self.x_values) != len(self.y_values)
+        if axes_are_different_lengths:
+            raise ValueError(
+                f"Cannot store TimeSeriesData with different length axes. "
+                f"{len(self.x_values)=}, {len(self.y_values)=}"
+            )
+        # Can't have this AND default to empty tuple
+        axes_are_zero_length = not self.x_values or not self.y_values
+        if axes_are_zero_length:
+            raise ValueError(
+                f"Cannot store TimeSeriesData with 0 length axes. "
+                f"{len(self.x_values)=}, {len(self.y_values)=}"
+            )
+        return self
+
+    @model_serializer(mode="wrap")
+    def custom_dump(self, handler, info: SerializationInfo):
+        """Serialize output for QRM compatibility."""
+        data = handler(self)
+        # change structure if mode="json" for QRM compatibility
+        if info.mode == "json":
+            # dump as list[list[Any]] with DatetimeIsoDict format for x_values
+            return [list(data["x_values"]), list(data["y_values"])]
+        return data
+
+    @model_validator(mode="before")
+    @classmethod
+    def handle_json(cls, input_value: Any):
+        """
+        Transform json input from list[list[Any]] to dict[Any, Any].
+
+        the dict is expected to be dict[str, tuple[Any, ...]], which gets validated by normal BaseModel configurations.
+        """
+        if isinstance(input_value, dict):
+            return input_value
+
+        if (
+            isinstance(input_value, (list, tuple))
+            and len(input_value) == 2
+            and isinstance(input_value[0], (list, tuple))
+            and isinstance(input_value[1], (list, tuple))
+        ):
+            return {"x_values": input_value[0], "y_values": input_value[1]}
+
+        return input_value
+
+
+class XYData(QualityModel):
+    """One or more time series for a single x-y plot."""
+
+    xlabel: str
+    ylabel: str
+    # the key is the name assigned to the series, e.g. within the legend
+    # the key cannot be None, because `null` is not a valid json key
+    series_data: dict[str, TimeSeriesData] = Field(default_factory=dict)
+    # TODO FUTURE - convert `series_name` to `legend_title` to better align with matplotlib terminology
+    series_name: str | None = None
+    ylabel_horizontal: bool | None = None
+    ylim: tuple[float | None, float | None] | None = None
+    plot_kwargs: dict[str, dict[str, Any]] = Field(default_factory=dict)
+    sort_series: bool | None = True
+
+
+class TableData(QualityModel):
+    """Tabular Data."""
+
+    # 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 TableData 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
+    # Note: numeric values are represented as strings for table data
+    rows: tuple[tuple[str, ...], ...]
+    header_row: bool | None = True
+    header_col: bool | None = False
+
+    @model_validator(mode="after")
+    def tuple_validation(self):
+        """Validate tuple lengths."""
+        row_count = len(self.rows)
+        if row_count == 0:
+            raise ValueError(f"Invalid table. No rows.")
+        header_column_count = len(self.rows[0])
+        if header_column_count == 0:
+            raise ValueError(f"Invalid table. No columns.")
+        row_column_counts = [len(row) for row in self.rows[1:]]
+        column_count_mismatch = any(
+            col_count != header_column_count for col_count in row_column_counts
+        )
+        if column_count_mismatch:
+            raise ValueError(
+                f"Mismatch in column count. {header_column_count=}, {row_column_counts=}"
+            )
+        return self
+
+
+class MultiPlotData(QualityModel):
+    """Multiple Plot Data."""
+
+    # TBD
+    pass
+
+
+class HistogramData(QualityModel):
+    """Histogram Data."""
+
+    # TBD
+    pass
+
+
+class ModMatData(QualityModel):
+    """Modulation Matrix Data."""
+
+    # TBD
+    pass
+
+
+class RaincloudData(QualityModel):
+    """Raincloud Data."""
+
+    # TBD
+    pass
+
+
+class EfficiencyData(QualityModel):
+    """Efficiency Data."""
+
+    # TBD
+    pass
+
+
+class QualityMetric(QualityModel):
+    """Quality Metric."""
+
+    name: str
+    description: str
+    metric_code: str
+    facet: str | None = None
+    statement: list[str] | None = None
+    plot_data: list[XYData] | None = None
+    multi_plot_data: list[MultiPlotData] | None = None
+    histogram_data: list[HistogramData] | None = None
+    table_data: list[TableData] | None = None
+    modmad_data: list[ModMatData] | None = None
+    raincloud_data: list[RaincloudData] | None = None
+    efficiency_data: list[EfficiencyData] | None = None
+    warnings: list[str] | None = None

{dkist_processing_common-12.9.0 → dkist_processing_common-12.10.0}/dkist_processing_common/tasks/l1_output_data.py

@@ -5,11 +5,13 @@ from abc import ABC
 from pathlib import Path
 from typing import Iterable
 
+from dkist_processing_common.codecs.basemodel import basemodel_decoder
 from dkist_processing_common.codecs.quality import quality_data_encoder
 from dkist_processing_common.models.message import CatalogFrameMessage
 from dkist_processing_common.models.message import CatalogFrameMessageBody
 from dkist_processing_common.models.message import CatalogObjectMessage
 from dkist_processing_common.models.message import CatalogObjectMessageBody
+from dkist_processing_common.models.quality import QualityMetric
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks.mixin.globus import GlobusMixin
 from dkist_processing_common.tasks.mixin.interservice_bus import InterserviceBusMixin
@@ -146,8 +148,13 @@ class AssembleQualityData(L1OutputDataBase, QualityMixin):
 
     def run(self):
         """Run method for the task."""
-        with self.telemetry_span("Assembling quality data"):
-            quality_data = self.quality_assemble_data(polcal_label_list=self.polcal_label_list)
+        # this is the new way, which will eventually supplant the old `quality_assemble_data`
+        with self.telemetry_span("Assembling generic quality data"):
+            quality_data = self.assemble_quality_data()
+
+        # this is the old way, which is being replaced by the new `assemble_quality_data`
+        with self.telemetry_span("Assembling quality data by Metric"):
+            quality_data += self.quality_assemble_data(polcal_label_list=self.polcal_label_list)
 
         with self.telemetry_span(
             f"Saving quality data with {len(quality_data)} metrics to the file system"
@@ -159,6 +166,16 @@ class AssembleQualityData(L1OutputDataBase, QualityMixin):
                 relative_path=f"{self.constants.dataset_id}_quality_data.json",
             )
 
+    def assemble_quality_data(self) -> list[dict]:
+        """Assemble Quality Data."""
+        metrics = []
+        tags = [Tag.quality("GENERIC")]
+        for metric in self.read(tags=tags, decoder=basemodel_decoder, model=QualityMetric):
+            # `metrics` needs to be list[dict] for compatibility with existing `quality_assemble_data`
+            # once all metric conversion is complete, `metrics` should be list[QualityMetric] instead
+            metrics.append(metric.model_dump(mode="json"))
+        return metrics
+
 
 class SubmitDatasetMetadata(L1OutputDataBase):
     """

{dkist_processing_common-12.9.0 → dkist_processing_common-12.10.0}/dkist_processing_common/tasks/mixin/quality/_base.py

@@ -28,7 +28,6 @@ class QualityMixin(
         """Assemble the quality data by checking for the existence of each metric."""
         report = []
         report += self.quality_task_independent_metrics()
-        report += self.quality_task_dependent_metrics()
 
         polcal_labels = polcal_label_list or []
         report += self.quality_polcal_metrics(polcal_labels)
@@ -43,15 +42,6 @@ class QualityMixin(
                 result.append(metric_func())
         return result
 
-    def quality_task_dependent_metrics(self) -> list[dict]:
-        """Encapsulate task dependent metric parsing."""
-        result = []
-        for metric_name, metric_func in self.quality_metrics_task_dependence.items():
-            for task_type in self.quality_task_types:
-                if self._quality_metric_exists(metric_name=metric_name, task_type=task_type):
-                    result.append(metric_func(task_type=task_type))
-        return result
-
     def quality_polcal_metrics(self, label_list: list) -> list[dict]:
         """Encapsulate polcal metric parsing."""
         result = []
@@ -82,22 +72,12 @@ class QualityMixin(
             "SENSITIVITY": self.quality_build_sensitivity,
             "HEALTH_STATUS": self.quality_build_health_status,
             "TASK_TYPES": self.quality_build_task_type_counts,
-            "DATASET_AVERAGE": self.quality_build_dataset_average,
-            "DATASET_RMS": self.quality_build_dataset_rms,
             "HISTORICAL": self.quality_build_historical,
             "AO_STATUS": self.quality_build_ao_status,
             "RANGE": self.quality_build_range,
             "WAVECAL_FIT": self.quality_build_wavecal_results,
         }
 
-    @property
-    def quality_metrics_task_dependence(self) -> dict:
-        """Return a dict of quality metrics which are dependent on the task."""
-        return {
-            "FRAME_AVERAGE": self.quality_build_frame_average,
-            "FRAME_RMS": self.quality_build_frame_rms,
-        }
-
     @property
     def quality_metrics_polcal(self) -> dict:
         """Return a dict of polcal quality metrics."""

{dkist_processing_common-12.9.0 → dkist_processing_common-12.10.0}/dkist_processing_common/tasks/mixin/quality/_metrics.py

@@ -12,10 +12,10 @@ from functools import partial
 from typing import Any
 from typing import Iterable
 from typing import Literal
+from typing import Sequence
 
 import astropy.units as u
 import numpy as np
-from astropy.wcs import WCS
 from dkist_processing_pac.fitter.fitter_parameters import CU_PARAMS
 from dkist_processing_pac.fitter.fitter_parameters import GLOBAL_PARAMS
 from dkist_processing_pac.fitter.fitter_parameters import TELESCOPE_PARAMS
@@ -186,7 +186,7 @@ class _SimplePlotQualityMixin:
         return all_plot_data
 
     @staticmethod
-    def _find_iqr_outliers(datetimes: list[str], values: list[float]) -> list[str]:
+    def _find_iqr_outliers(datetimes: Sequence[datetime], values: Sequence[float]) -> list[str]:
         """
         Given a list of values, find values that fall more than (1.5 * iqr) outside the quartiles of the data.
 
@@ -314,90 +314,6 @@ class _SimplePlotQualityMixin:
             warnings=None,
         )
 
-    def quality_store_frame_average(
-        self,
-        datetimes: list[str],
-        values: list[float],
-        task_type: str,
-        modstate: int | None = None,
-    ):
-        """Collect and store datetime / value pairs for the individual frame averages."""
-        tags = [Tag.quality(MetricCode.frame_average)]
-        if modstate:
-            tags.append(Tag.modstate(modstate))
-        self._record_2d_plot_values(
-            x_values=datetimes,
-            y_values=values,
-            tags=tags,
-            series_name=modstate or 1,
-            task_type=task_type,
-        )
-
-    def quality_build_frame_average(self, task_type: str) -> dict:
-        """Build frame average schema from stored data."""
-        # This will load data for all modstates, if present
-        series_data = self._load_2d_plot_values(
-            tags=Tag.quality(MetricCode.frame_average), task_type=task_type
-        )
-
-        # Build metric dict
-        if len(series_data) > 0:
-            datetimes, values = list(series_data.values())[0]
-            warnings = self._find_iqr_outliers(datetimes=datetimes, values=values)
-            return self._create_2d_plot_with_datetime_metric(
-                name=f"Average Across Frame - {task_type.upper()}",
-                description=f"Average intensity value across frames of task type {task_type}. One measurement is taken per frame in each task type.",
-                metric_code=MetricCode.frame_average,
-                facet=task_type.upper(),
-                xlabel="Time",
-                ylabel="Average Value (adu / sec)",
-                series_data=series_data,
-                series_name="Modstate",
-                warnings=self._format_warnings(warnings),
-            )
-
-    def quality_store_frame_rms(
-        self,
-        datetimes: list[str],
-        values: list[float],
-        task_type: str,
-        modstate: int | None = None,
-    ):
-        """Collect and store datetime / value pairs for the individual frame rms."""
-        tags = [Tag.quality(MetricCode.frame_rms)]
-        if modstate:
-            tags.append(Tag.modstate(modstate))
-        self._record_2d_plot_values(
-            x_values=datetimes,
-            y_values=values,
-            tags=tags,
-            series_name=modstate or 1,
-            task_type=task_type,
-        )
-
-    def quality_build_frame_rms(self, task_type: str) -> dict:
-        """Build frame rms schema from stored data."""
-        # This will load data for all modstates, if present
-        series_data = self._load_2d_plot_values(
-            tags=Tag.quality(MetricCode.frame_rms), task_type=task_type
-        )
-
-        # Build metric dict
-        if len(series_data) > 0:
-            datetimes, values = list(series_data.values())[0]
-            warnings = self._find_iqr_outliers(datetimes=datetimes, values=values)
-            return self._create_2d_plot_with_datetime_metric(
-                name=f"Root Mean Square (RMS) Across Frame - {task_type.upper()}",
-                description=f"RMS value across frames of task type {task_type}. One measurement is taken per frame in each task type.",
-                metric_code=MetricCode.frame_rms,
-                facet=task_type.upper(),
-                xlabel="Time",
-                ylabel="RMS (adu / sec)",
-                series_data=series_data,
-                series_name="Modstate",
-                warnings=self._format_warnings(warnings),
-            )
-
     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(
@@ -565,81 +481,6 @@ class _TableQualityMixin:
             warnings=self._format_warnings(warnings),
         )
 
-    def quality_store_dataset_average(self, task_type: str, frame_averages: list[float]):
-        """
-        Collect and store dataset average.
-
-        Parameters
-        ----------
-        task_type: task type as listed in the headers
-        frame_averages: average value of all pixels in each frame of the given task type
-        """
-        data = {"task_type": task_type, "frame_averages": frame_averages}
-        self._record_values(values=data, tags=Tag.quality(MetricCode.dataset_average))
-
-    def quality_build_dataset_average(self) -> dict:
-        """Build dataset average schema from stored data."""
-        dataset_averages = defaultdict(list)
-        # Loop over files that contain data for this metric
-        for path in self.read(tags=Tag.quality(MetricCode.dataset_average)):
-            with path.open() as f:
-                data = json.load(f)
-                # Add counts for the task type to its already existing counts
-                dataset_averages[data["task_type"]] += data["frame_averages"]
-
-        # Now, build metric from the counts dict
-        table_data = [[i[0], round(np.mean(i[1]), 2)] for i in dataset_averages.items()]
-        # Add header row
-        table_data.insert(0, ["Task Type", "Dataset Average (adu / sec)"])
-        return self._create_table_metric(
-            name="Average Across Dataset",
-            description="This metric is the calculated mean intensity value across data from an "
-            "instrument program task type used in the creation of an entire L1 "
-            "dataset.",
-            metric_code=MetricCode.dataset_average,
-            rows=table_data,
-            warnings=None,
-        )
-
-    def quality_store_dataset_rms(self, task_type: str, frame_rms: list[float]):
-        """
-        Collect and store dataset average.
-
-        Parameters
-        ----------
-        task_type: task type as listed in the headers
-        frame_rms: rms value of all pixels in each frame of the given task type
-        """
-        data = {"task_type": task_type, "frame_rms": frame_rms}
-        self._record_values(values=data, tags=Tag.quality(MetricCode.dataset_rms))
-
-    def quality_build_dataset_rms(self) -> dict:
-        """Build dataset rms schema from stored data."""
-        dataset_rms = {}
-        # Loop over files that contain data for this metric
-        for path in self.read(tags=Tag.quality(MetricCode.dataset_rms)):
-            with path.open() as f:
-                data = json.load(f)
-                # If the task type isn't in the dict, add it with counts set to zero
-                if not data["task_type"] in dataset_rms.keys():
-                    dataset_rms[data["task_type"]] = []
-                # Add counts for the task type to its already existing counts
-                dataset_rms[data["task_type"]] += data["frame_rms"]
-
-        # Now, build metric from the counts dict
-        table_data = [[i[0], round(np.mean(i[1]), 2)] for i in dataset_rms.items()]
-        # Add header row
-        table_data.insert(0, ["Task Type", "Dataset RMS (adu / sec)"])
-        return self._create_table_metric(
-            name="Dataset RMS",
-            description="This metric is the calculated root mean square intensity value across data"
-            " from an instrument program task type used in the creation of an entire "
-            "L1 dataset.",
-            metric_code=MetricCode.dataset_rms,
-            rows=table_data,
-            warnings=None,
-        )
-
     def quality_store_historical(self, name: str, value: Any, warning: str | None = None):
         """
         Insert historical data into the schema used to record quality info.